slides.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d21e3400-617c-44d5-b0c5-5f4bbcc1ec6f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "<center>\n",
    "    <h1>Debugging and Profiling Python Code</h1>\n",
    "    <h2>Andres Rios-Tascon</h2>\n",
    "    <h4>Software Engineering Summer School 2024</h4>\n",
    "    <img src=\"images/PU_lockup.png\" style=\"height:50px;\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f5e138f-91de-418c-94f4-585c53794134",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Profiling and Debugging\n",
    "\n",
    "One of the main tasks in software engineering is developing code that runs **fast** and **correctly**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6f049e4-3575-4fca-a4e2-9ff8e31f7de3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "**Profiling** and **debugging** is how you achieve this."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3ae6f81-00b9-4eee-a917-276b4d382ca3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- **Profiling:** The process of analyzing a program to measure its performance, usually in terms of execution time and memory usage, to identify bottlenecks and optimize efficiency."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a02ba677-7c53-4006-9587-d1507c035376",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- **Debugging:** The process of identifying, isolating, and fixing bugs or errors in a software program to ensure it runs correctly and efficiently."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2b8c181-983f-4098-b2e1-2d60ccdb1c6e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Profiling and debugging differs depending on the language and platform you are working with, but the basics are the same."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8b0cc60-c34e-4726-bc1e-2f4b671b8316",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Today we will be working with Python code, but the skills you will learn are transferable."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c29309c6-aa86-41df-9448-1867e49358dc",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Profiling Python Code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4f616f6-87b2-48a6-a515-31c8ed36363c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Getting Python code to run efficiently can be tricky, especially since it is an interpreted language so it is inherently slower."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df248085-5bb7-4edc-baa5-ad3b4c009db8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Using built-in functions and compiled extension libraries, with proper code design, and with the aid of profiling tools, you can nevertheless write very efficient Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ba9d7a-d56b-4078-8234-9f1318acc286",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Today we'll be learning how to use `cProfile` and `line_profiler`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c10ee01-4923-47b5-86ad-ddf2372ea3d8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## `cProfile`\n",
    "\n",
    "- `cProfile` is a built-in profiler (along with `profile`, which is a pure-Python version)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e8c0bfa-5061-4498-9318-ece0f6954721",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- It provides similar functionality to what you would typically find in profilers for compiled languages (e.g. the Linux `perf` profiler)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51659f1-8d2c-4d50-82ed-fd989676caf6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Gives us information about the functions that are running as we run our scripts, so that we can focus on improving the most time-consuming parts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df961fe-ccbb-496a-bdc7-5576545951b7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## `cProfile` example\n",
    "\n",
    "Let's look at a simple example. The following code block contains a `fibonacci` method that computes the $n$-th element of the Fibonacci sequence with 3 different approaches.\n",
    "\n",
    "$$F_{n}=F_{n-1}+F_{n-2}, \\text{ with } F_{0}=0, F_{1}=1$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf466861-380d-432e-8fe6-f0648a378cbe",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from functools import cache\n",
    "\n",
    "def fib_recursive(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fib_recursive(n-1) + fib_recursive(n-2)\n",
    "\n",
    "@cache\n",
    "def fib_recursive_cached(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fib_recursive_cached(n-1) + fib_recursive_cached(n-2)\n",
    "\n",
    "def fib_iterative(n):\n",
    "    a, b = 0, 1\n",
    "    for _ in range(n):\n",
    "        a, b = b, a + b\n",
    "    return a\n",
    "\n",
    "def fibonacci(n):\n",
    "    f_re_n = fib_recursive(n)\n",
    "    print(f\"Fibonacci recursive ({n}): {f_re_n}\")\n",
    "    # Clear the cache so that profiling is accurate.\n",
    "    # Don't use in real code.\n",
    "    fib_recursive_cached.cache_clear()\n",
    "    f_rec_n = fib_recursive_cached(n)\n",
    "    print(f\"Fibonacci recursive cached ({n}): {f_rec_n}\")\n",
    "    f_it_n = fib_iterative(n)\n",
    "    print(f\"Fibonacci iterative ({n}): {f_it_n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcefb728-7d52-4746-806d-7ec668c01df5",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Let's try it out to see how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56d621d7-6b53-4e7e-8cfe-a81b76e8196e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fibonacci(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b90b6f2-1c61-4d8d-9df9-a0ba50b9c094",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Let's now see how to profile it. We first import `cProfile`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbddc190-461e-4aaf-8391-e1f8ac22aca2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import cProfile"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35171747-427b-4e34-81af-c548a0fd3d0a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "And then we can run the profiler like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaf7c8ff-8387-490c-9424-033f1f376b03",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "cProfile.run(\"fibonacci(30)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3726d5d-372d-404a-b8a8-1bf51d35ffd3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed5a3ae7-3cc6-4d6a-a726-ddc5d14b92a9",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "You will typically have much longer functions, so it will be a lot harder to read through this output.\n",
    "\n",
    "What we can do is output this information to a new file, and then use `pstats` to look through the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb082fb-9b7b-465d-a01f-7869df9a4d58",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "cProfile.run(\"fibonacci(30)\", \"fibonacci_stats\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2828c48a-5998-4dc7-b3fb-507b898c371f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pstats\n",
    "from pstats import SortKey\n",
    "p = pstats.Stats(\"fibonacci_stats\")\n",
    "p.strip_dirs().sort_stats(SortKey.FILENAME, SortKey.CALLS, SortKey.TIME).print_stats(23);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a721b27-a37a-47e3-aab9-3594f09ce05c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "The idea now is to look for function calls that have large run time or number of calls. Once identified, you can start looking at the code to see what could be improved."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd43016-8440-4d34-88e1-abd5800a37ae",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## `line_profiler`\n",
    "\n",
    "- Since Python is an interpreted language, we can easily profile with more detail to see exactly which lines of code are taking a long time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa8a680-e3a5-4fc6-ba5e-32de7a66b5ff",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- This can be done with the `line_profiler` package, which can be installed with `pip install line_profiler`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38923082-c21d-4e04-82cb-41ca76782b14",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## `line_profiler` example\n",
    "\n",
    "We can use this package in a Jupyter notebook by first loating it as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f8f67b4-b8d1-41a4-9c69-7a4319760763",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%load_ext line_profiler"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cd3cd91-eb13-46a1-8c5b-3fecdf23e1ad",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Then, we use `%lprun` by specifying the functions that it should profile, as well as a statement to run. For example, for the Fibonacci example above, we would do it as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e7e070f-4562-4f69-80f9-1943d933c8e7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%lprun -f fibonacci fibonacci(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa525081-de17-4ce5-9021-ed1a1fe9646c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Since we see that most of the time is being spent in `fib_recursive`, let's also profile it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "188cd02c-fab0-4b72-857d-67b8bc55c2da",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%lprun -f fibonacci -f fib_recursive fibonacci(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab187e6c-2d7e-4184-b649-796b9c0393c2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "We can see that the recursion in `fib_recursive` is causing an excessive number of function calls, which is why it is so slow."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43f3605c-f2c3-498d-8f66-74a4d3ee5414",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Another example\n",
    "\n",
    "Let's biefly look at another example. The following code block contains some functions to compute the sum of consecutive integers. Let's use the line profiler to look at their performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7db86056-387d-4ce5-8655-5270898ac458",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def bad(n):\n",
    "    total = 0\n",
    "    for i in range(n):\n",
    "        total += i\n",
    "    return total\n",
    "\n",
    "def good(n):\n",
    "    return sum(i for i in range(n))\n",
    "\n",
    "def best(n):\n",
    "    return (n*(n-1))//2\n",
    "\n",
    "def sum_of_integers(n):\n",
    "    \"\"\"\n",
    "    Sum integers from 1 up to, but not including, n.\n",
    "    Uses 3 different algorithms, to show performance difference.\n",
    "    \"\"\"\n",
    "    res_bad = bad(n)\n",
    "    print(f\"Result from bad function ({n}): {res_bad}\")\n",
    "    res_good = good(n)\n",
    "    print(f\"Result from good function ({n}): {res_good}\")\n",
    "    res_best = best(n)\n",
    "    print(f\"Result from best function ({n}): {res_best}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3795c01b-7afb-4e7a-bd40-d6a19e341d45",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%lprun -f bad -f good -f best -f sum_of_integers sum_of_integers(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "406971ce-11d6-4163-9a02-d6294995c83e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb268df6-9a3e-45ce-8183-6546b5700276",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Tips for improving performance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77c90d33-dbe2-4390-a173-f0923370191c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Use built-in functions whenever possible."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b22e2c2b-e17b-40fa-802e-5af6d536cbb6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Find a library (ideally compiled) for the type of data/problem you are working with. E.g. if you want to work with numerical arrays, use `NumPy`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ace500-af58-4ee4-b661-b345a45bac98",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- A good algorithm will always be the most important thing. However, this requires a good understanding of the computation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3057cb3-0cd7-49f5-b7d8-c34e6397fefb",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Exercise 1\n",
    "\n",
    "Profile the following code and find ways to make it faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb219231-653a-4d08-8892-661cb96de26b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def calc_pi(num_trials):\n",
    "    \"\"\"Calculate pi using random numbers\"\"\"\n",
    "    xarr = []\n",
    "    yarr = []\n",
    "\n",
    "    for _ in range(num_trials):\n",
    "        xarr.append(np.random.rand())\n",
    "        yarr.append(np.random.rand())\n",
    "\n",
    "    in_circle = 0\n",
    "    for x, y in zip(xarr, yarr):\n",
    "        if x**2 + y**2 <= 1.0:\n",
    "            in_circle += 1\n",
    "\n",
    "    return 4*(in_circle/num_trials)\n",
    "\n",
    "calc_pi(1_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40aa9b09-618b-4860-919d-62fc54cfd2de",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%lprun -f calc_pi calc_pi(1_000_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8968df2-51ab-42b2-af61-8a0586dba994",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<details>\n",
    "<summary>\n",
    "Answer (Don't look until you're done)\n",
    "</summary>\n",
    "This would be a good way to make this function faster.\n",
    "<pre><code>\n",
    "def calc_pi(num_trials):\n",
    "    \"\"\"Calculate pi using random numbers\"\"\"\n",
    "    x = np.random.rand(num_trials)\n",
    "    y = np.random.rand(num_trials)\n",
    "\n",
    "    in_circle = np.sum(x**2 + y**2 <= 1.0)\n",
    "\n",
    "    return 4*(in_circle/num_trials)\n",
    "</code></pre>\n",
    "\n",
    "Note that we used functions built into NumPy instead of writing for-loops. Not only is the code faster, but shorter and more legible.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57c0bc52-2478-4e6a-ae41-8f3ec7891c13",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Memory profiling\n",
    "\n",
    "Unfortunately, memory profiling in Python is currently in a bit of a rough spot. `memory-profiler` and the `filprofiler` were good tools developed for this, but they are not actively supported. If you need to perform memory profiling, these might still be the best options. We won't cover these today."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "708c3a20-c532-48d9-b3a8-39d9cd436447",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Debugging Python Code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d1b668-ad8b-4ba3-a9e6-6dc52c86fc7f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- As you write code, you will inevitably make mistakes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83ca7da4-4514-4256-9e2e-21cfa3048942",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Some bugs will be immediately obvious, but other will only show up in edge cases and will be difficult to tell what is wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6fa6348-21e6-45c5-a0c6-c25dc82fb1e0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Bugs that make the program crash are easier to debug in Python, since it tells you exactly where it failed. But logical bugs are equally difficult to solve."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef29839f-710c-4e61-a9e7-369ed9f79bc2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- There are debugging tools that help you find and fix tricky bugs. They work similarly for other languages, so what you will learn here is transferable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ba8de9-6aee-499d-9791-10a0aabaad95",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## The \"classic\" approach"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f29fc67b-141b-429f-a3dd-4fd2aa040e29",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- The first instinct for most people when encountering a bug is to add print statements in strategic places in the code to see what is happening."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc983cdc-346d-4625-8f3f-97b73490634a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- It is considered a \"bad practice\" by some people, but the truth is that all of us do it, and it is a good and quick approach to fix simple bugs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db58851e-6fee-4988-94ef-2b0c80638cf0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- One thing that you should keep in mind is that prints are often buffered, so if the code crashes shortly after a print statement it might not end up printing anything. In Python you can force an unbuffered print with `print(..., flush=True)`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900c10d5-9514-4572-9aeb-7fdf96064d8a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Using a debugger"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50573f66-0a49-4668-9f96-3dfab7a25bbd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- For complex bugs, it is much better to use a debugger, as it allows you to take a detailed look at what is happening as the program runs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f53e2302-3e13-439f-99f4-77e8bd655a81",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Python comes with a built-in debugger called `pdb`, which works similarly to `gdb`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9be874b3-dcbb-4b17-91cb-369cf4b4f552",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Debugging example\n",
    "\n",
    "Let's consider the following broken function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13ead935-1da4-4a6d-8aca-1815b7c638b0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_broken_function():\n",
    "    x = 6\n",
    "    y = 4\n",
    "    x += 2\n",
    "    y *= 2\n",
    "    x -= y\n",
    "    y /= x\n",
    "    return x, y\n",
    "\n",
    "my_broken_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ed6d691-82de-4b6e-861a-9f8750db4be1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "We can tell it to jump into the debugger by using the magic command `%debug` at the top of the cell. If you're running a python script, you can use `python -m pdb -c continue myscript.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf3fda09-2e51-4c78-b06d-ea8000953ae7",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "For a full description of how to use `pdb` you can visit [this page](https://docs.python.org/3/library/pdb.html). Let's try it out on the code above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88195cc3-844f-45ec-8ca1-a6500dff2e12",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Often, it is better to start the debugger a bit before the crash happens, so we can step through each line and see what went wrong. We can do this with `import ipdb; ipdb.set_trace()`, or if you are not using Jupyter, simply with the `breakpoint()` function. Let's try it out above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3e88acc-1724-4755-9226-d02a29841f3d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Debugging example in JupyterLab\n",
    "\n",
    "When working with JupyterLab, there is an alternative way to debug more directly and visually. You first need to enable debugging with the bug button at the top right. You can then use the debugging panel on the right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa70e47-a18a-4f82-96d4-7e826174f06a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "Let's try it out with the following function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7aca4e58-e325-4c6c-95f2-e8867acdc2c8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def average_of_5_largest(in_list):\n",
    "    sorted_list = in_list.sort()\n",
    "    largest_5 = sorted_list[-5:]\n",
    "    sum_of_largest = sum(largest_5)\n",
    "    length_of_largest = len(largest_5)\n",
    "    average_of_largest = sum_of_largest/length_of_largest\n",
    "    return average_of_largest\n",
    "\n",
    "average_of_5_largest([0,1,2,3,4,5,6,7,8,9])\n",
    "average_of_5_largest([0,1,2])\n",
    "average_of_5_largest([])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f703dc3-44a8-41e2-a456-21c4ae70f891",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Exercise 2\n",
    "\n",
    "Debug and fix the following code.\n",
    "\n",
    "The `sylvester` function computes Sylvester's sequence up to the $n$-th element.\n",
    "$$s_n=1+\\prod_{i=0}^{n-1}s_i, \\text{ with } s_0=2$$\n",
    "\n",
    "The sequence should be $2, 3, 7, 43, 1807, 3263443, 10650056950807, \\cdots$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3a59bc3-07e1-49bc-a590-4220f68ef1eb",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from math import prod\n",
    "\n",
    "def add_to_list(*elements, starting_list=[]):\n",
    "    starting_list.extend(elements)\n",
    "    return starting_list\n",
    "\n",
    "def sylvester(n):\n",
    "    sequence = add_to_list(2)\n",
    "    for _ in range(n-1):\n",
    "        new_num = 1 + prod(sequence)\n",
    "        sequence = add_to_list(new_num, starting_list=sequence)\n",
    "    return sequence\n",
    "\n",
    "print(sylvester(2))\n",
    "print(sylvester(3))\n",
    "print(sylvester(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b285761c-8f37-443d-97c5-a2b2e9ab1bdd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "<details>\n",
    "<summary>\n",
    "Answer (Don't look until you're done)\n",
    "</summary>\n",
    "By using breakpoints, we can find that sometimes at the the very start of the <code>add_to_list</code> function,\n",
    "the <code>starting_list</code> is not empty even though we didn't specify it when calling the function.\n",
    "\n",
    "This happens because default arguments for function are initialized when the function is defined. A mutable argument\n",
    "will not be reinitialized for new function calls, so it keeps any changes that were made during previous calls.\n",
    "This is a common mistake to make when writing Python code.\n",
    "\n",
    "The correct function definition should be something like this\n",
    "<pre><code>\n",
    "def add_to_list(*elements, starting_list=None):\n",
    "    if starting_list is None:\n",
    "        starting_list = []\n",
    "    starting_list.extend(elements)\n",
    "    return starting_list\n",
    "</code></pre>\n",
    "<br/>\n",
    "Note that this is a rather contrived example since we should be using <code>append</code> directly, but it shows a common mistake you might encounter.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7152684-eb1b-4ec9-94ff-aedb93f5781e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39e9fee5-a7f7-40f2-8873-e4167ed95d96",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- As you write code, you need to ensure that it runs both **efficiently** and **correctly**. **Profiling** and **debugging** tools help you achieve this."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a88cc055-35dc-445d-8b7f-795bae7cdf1d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Learning how to profile and debug properly takes practice. There's no step-by-step guide, so the best thing you can do is practice with your own projects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3458f64f-a644-4a73-b88c-ac960dbfa23b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "- Today, I showed you some tools to profile and debug for Python, but the basics are the same for any other language."
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}