B03 Badge - Debugging + Variable Types v1.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Badge 03: Debugging."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: This is a **JUPYTER NOTEBOOK**. It's a type of website where you can edit and run computer programs (code). \n",
    "You interact with it in your web browser and you can find it via your Learn.\n",
    "\n",
    "1. These blocks here are cells.\n",
    "2. There are **TEXT CELLS** like this one with explanations of concepts.\n",
    "3. and **CODE CELLS** with Python code (see below). Code cells have a ```In []``` written to the left. If there's a number inside the ```In []```, then the cell has been run.\n",
    "4. You can **RUN CODE CELLS** by clicking on them and pressing **Shirt + Enter**. When you run a cell code in it is run (it \"happens\", computer will do what you asked for it to do). Results of what your code does will appear underneath the cell.\n",
    "5. As we go through these lessons, please READ text cells, and RUN code cells.\n",
    "6. Good luck!\n",
    "\n",
    "✅ Remmeber to RUN ALL THE CELLS IN ORDER AS YOU GO THROUGH THIS NOTEBOOK. If you skip some, you might see some unexpected errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🎯 Learning objectives:\n",
    "\n",
    "At the end of this badge you will know:\n",
    "\n",
    "- What are some basic types of errors.\n",
    "- How to refactor your code so that it is easier to debug.\n",
    "\n",
    " 🎯 End of learning objectives 🎯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Errors: Learn to 'speak the error language' (how to read the error messages)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if you ask python to add a string and a number, it will not know whether to use 'string adding' or 'number adding'. Run below code and read the error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"My age is \" + 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ERRORS ARE YOUR FRIENDS: Learn to read them and they will guide you through solving your problems. \n",
    "Usually the most important part of the error in on the bottom ```TypeError: can only concatenate str (not \"int\") to str```. This means something is wrong with the TYPE of data. \n",
    "Also notice that the ```---->``` arrow usually points exactly to the line of code where your error happens.\n",
    "You can only concatenate (add, join) a string to string, but not to an integer.\n",
    "\n",
    "Here are some other errors for you to understand. Before you run the code, try to think of what is wrong in the below lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before you run the code, try to think of what is wrong in the below lines:\n",
    "print(23 + \"is my age\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example is when an operation is defined for some data types, but not for others. For example it is easy to subtract numbers, but much more complicated to do it with strings (we'll learn about how to do it soon)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(23 - 10) # This will work.  \n",
    "print(\"banana\" - \"na\") # But this will fail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**REMEMBER: ERRORS ARE YOUR FRIENDS AND THEY REALLY ARE TRYING TO TELL YOU WHAT'S WRONG. YOU JUST NEED TO LEARN HOW TO INTERPRET THEM.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try running the code snippets below, and see some other examples of errors. Read them carefully and try to learn what the error is intending to say."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before you run the code, try to think of what is wrong in the below lines:\n",
    "print(23 / 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before you run the code, try to think of what is wrong in the below lines:\n",
    "print(the_tasty_fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before you run the code, try to think of what is wrong in the below lines:\n",
    "# Would this be an error?\n",
    "print( 3 == \"Pinapple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"Pinapple\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raising errors on purpose."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally sometimes you can raise errors intentionally. \n",
    "This can often be used to let other parts of your program know that something went really wrong, or as a reminder to yourself that you forgot to write something.\n",
    "\n",
    "You are not likely to do it in your own code, but **You will see it in other people's code**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The message below is how I will tell you that you need to write some code here.\n",
    "# When you see one of these, DELETE IT, and replace it with some code. \n",
    "# It's not only for tidiness, but if left, it can cause strange erros within your work.\n",
    "\n",
    "raise NotImplementedError() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For the curious: Creating your own errors.\n",
    "\n",
    "Well actually, at some point of your coding journey, you will start creating and *'throwing'* your own Errors / Exceptions to tell other programmers what they did wrong in a clear and concise way. \n",
    "E.g. if your code expects two numbers and instead it gets a number and a False... you might choose to throw an exception to tell other coders, or users, what went wrong. \n",
    "To do this successfully, you need to know how Object Oriented code works, so we'll come back to that later.\n",
    "\n",
    "E.g. Imagine you're writing a program for dividing a restaurant bill between many people. \n",
    "Your code will ask how much was the bill, and how many people there are. \n",
    "But what if someone by accident typed that there are 0 people? Or typed a word instead of a number in the amount? \n",
    "You might choose then to create your own error that other programmers can ANTICIPATE, and so they can RECOVER from it. \n",
    "You'll see examples of it towards the end of the course.\n",
    "\n",
    "Example:\n",
    "\n",
    "Remember the time you ordered something online. \n",
    "Imagine that while you were filling in your contact details, you forgot to enter your email. \n",
    "The form complained in big red letters: 'You forgot to enter your email'. \n",
    "Ok, so you type your email in, but you made a typo, and typed # instead of @ (eg. 'patricia#gmail.com' instead of 'patricia@gmail.com'). \n",
    "The form would complain 'this does not look like an email address. It is missing an @'. \n",
    "These are custom error messages in action: programmers creating that website anticipated what could go wrong, and tried to give users some meaningful messages. \n",
    "Sometimes they even try to help you, (like spellcheck does on your phone) by saying something like: \"Did you mean patricia@gmail.com?\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Good Coding Practices: Refactoring code (making it better)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TEMPORARY VARIABLES**: All variables are temporary, because they are stored in the computer's temporary memory - when your program reaches the end, variables are deleted (eg. when you close a Notebook). \n",
    "When you run a program next time, you will have to start with an empty slate.\n",
    "\n",
    "**READABLE CODE**: You are not only writing the code for the computer to understand - you are writing code that can be understood easily by others, and your future self.\n",
    "\n",
    "**REFACTORING CODE**: Improving the way your code is written without changing what it does (functionality). We refactor code to make programs more understandable to others, make them easier to maintain (change, adjust) and to make it more elegant. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is an example of refactoring a piece of code. \n",
    "We'll start with a messy version, and clean it up, but we will \n",
    "**TRY TO NOT CHANGE WHAT THE CODE DOES JUST HOW IT IS WRITTEN**. \n",
    "Often to make your code readable, you will use variables for cleanliness of your code, or to separate tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Version 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# V1. The worst: Short, but confusing code and result.\n",
    "print(\"Results of operations on\",9, \"and\",3, \"are\", 9+3, 9-3, 9*3, 9/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** What if your client asks you to change one of the numbers? \n",
    "How many places whithin your code will you need to make a change? \n",
    "And with each manual code change comes a danger of introducing bugs, typos or deleting something by accident. \n",
    "Copy-pasting is also very bad and error-prone.\n",
    "\n",
    "**Improvement:** Extract all changable things into variables, so you can change the value in just one place, and it will be changed everywhere it is then used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Version 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# V2. Still Bad, but already more universal: Extract all changeable things into variables:\n",
    "\n",
    "number_1 = 9\n",
    "number_2 = 3\n",
    "print(\"Results of operations on\",number_1, \"and\",number_2, \"are\", number_1+number_2, number_1-number_2, number_1*number_2, number_1/number_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** It is rather hard to read the code (eg. the lines are very long and you need to scroll sideways). \n",
    "Actual calculations are intermingled with the way they are presented, and that is almost always a bad idea: it means that by changing the maths you might by accident change the way things look, and the other way around. \n",
    "Separation of responsibilities is a great idea in code.\n",
    "\n",
    "**Improvement:** Separate the calculations from displaying them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Version 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# V3. Better: broken down, clearer code, but still leads to a confusing output.\n",
    "\n",
    "number_1 = 9\n",
    "number_2 = 3\n",
    "\n",
    "added = number_1 + number_2\n",
    "subtracted = number_1 - number_2\n",
    "multiplied = number_1 * number_2\n",
    "divided = number_1 / number_2\n",
    "\n",
    "print(\"Results of operations on\",number_1, \"and\",number_2, \"are\", added, subtracted, multiplied, divided)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** It is hard for the user to read the output and they need to guess what exactly we meant (guessing is bad!). \n",
    "As a programmer you need to practice EMPATHY towards the person who will be using the programs or reports that you create.  \n",
    "\n",
    "**Improvement:** Explain in the output what each piece of information means."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Version 4:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# V4. Even better: separation of values, operations and presentation.\n",
    "\n",
    "number_1 = 9\n",
    "number_2 = 3\n",
    "\n",
    "added = number_1 + number_2\n",
    "subtracted = number_1 - number_2\n",
    "multiplied = number_1 * number_2\n",
    "divided = number_1 / number_2\n",
    "\n",
    "print() # Note: optional empty print() will add a new empty line.\n",
    "print(\"Operations on\",number_1, \"and\",number_2)\n",
    "print(\"Added:\", added)\n",
    "print(\"Subtracted:\", subtracted)\n",
    "print(\"Multiplied:\", multiplied)\n",
    "print(\"Divided:\", divided)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**HOW TO MEASURE QUALITY OF CODE**: There are some ways to measure of whether your code is good:\n",
    "\n",
    "Bad measures of code quality:\n",
    "\n",
    "1. Length of code or number of lines: Note that version 1 above was the shortest and most condensed, but it was hard to read and hard to change. \n",
    "When you need to spend time untangling the code to guess what the programmer meant, you are dealing with **Spaghetti Code** (not a good thing).\n",
    "\n",
    "Good measures of code quality:\n",
    "\n",
    "1. Code compiles and does not throw errors.\n",
    "2. Code does what it is meant to do.\n",
    "3. Code is easy to read for yourself and others, with  meaningful variable names.\n",
    "4. Code is not repeated too much. We say that code is DRY (Don't Repeat Yourself).\n",
    "5. Code is maintainable: Whenever you want to make changes, you need to change the least lines of code. Like in the improvement from version 1 to version 2 above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What you have learned in this session: Three stars and a wish."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In your own words** Write in your Learn diary:\n",
    "\n",
    "- 3 things you would like to remember from this badge.\n",
    "- 1 thing you wish to understand better in the future or a question you'd like to ask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Bonus Minitask: Deconstructing a task.\n",
    "\n",
    "- Write a code that will be able to generate the below sentence based on some variable values.\n",
    "- Use maningful variable names.\n",
    "- Imagine that you were to come back to this code in a month. Make it so that you would understand what it does within seconds.\n",
    "\n",
    "(This sentence is just a guideline, feel free to change / adjust it)\n",
    "\n",
    "```\n",
    "\"A person earns 12.5 pounds per hour and worked 32 hours this month. They need to pay 22% tax and 40 pounds of insurance. This means that they will get 272.0 pounds into their account at the end of the month. For which they can buy 22 books at an average price of 11.99\".\n",
    "```\n",
    "\n",
    "Remember to every now and then save your progress (File > Save, or a keyboard shortcut OR click the DISK icon, to the left of the top menu in your Notebook) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here you can write your code (to add more cells, use '+' symbol in top menu)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hints: \n",
    "\n",
    "# How to round numbers: round(some_number, number_of_decimals_to_keep)\n",
    "print(round(10.8123124, 2))\n",
    "\n",
    "print()\n",
    "print(\"divide:\", 23 / 3) # Division.\n",
    "print(\"whole divide:\", 23 // 3) # Whole amount of times one fits in the other.\n",
    "print(\"round:\", round(23 / 3)) # Round to nearest whole number.\n",
    "print(\"crop to whole numbers:\", int(23 / 3)) # Just take the whole numbers (no rounding).\n",
    "print(\"remainder:\", 23 % 3) # Remainder of the division."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 1: Breakdown calculations: CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    ### BEGIN SOLUTION\n",
    "    wages_per_hour =  12.5\n",
    "    hours_worked = 32\n",
    "\n",
    "    tax_percent = 22\n",
    "    insurance_to_pay = 40\n",
    "\n",
    "    wages_earned = wages_per_hour*hours_worked\n",
    "    tax_to_pay = wages_earned * (tax_percent / 100)\n",
    "    final_wages = wages_earned - tax_to_pay - insurance_to_pay \n",
    "    final_wages = round(final_wages)\n",
    "    print(final_wages)\n",
    "\n",
    "    book_price = 11.99\n",
    "    books_they_can_buy = int(final_wages // book_price)\n",
    "    print(books_they_can_buy)\n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 2: Printing: CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    ### BEGIN SOLUTION\n",
    "    print(\"A person earns\",wages_per_hour,\"pounds per hour and worked\",hours_worked,\"hours this month\")\n",
    "    print(\"They need to pay\",tax_percent,\"% tax and\",insurance_to_pay,\"pounds of insurance.\")\n",
    "    print(\"This means that they will get\",final_wages,\"pounds into their account at the end of the month.\")\n",
    "    print(\"For which they can buy\",books_they_can_buy,\"books at an average price of\",book_price)\n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}