04-editing_existing_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Editing Existing Code\n",
    "\n",
    "Copilot can be used to edit or add to existing code in a number of useful ways. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documenting and Commenting Code\n",
    "\n",
    "Properly documenting and commenting code is important for making it understandable and maintainable, particularly if you're collaborating with others, or intend to share your code publicly. It's often a task that programmers choose to put off as it can be time-consuming and tedious. Copilot can help with this by generating comments for you, based on the code you've written.\n",
    "\n",
    "The best way to do this is to highlight a section of code, then press `Ctrl + I`, then type in ```/doc``` to ask Copilot to generate docstrings for any functions in your code. You may have to do this one function at a time, You can also write a command like \"comment this\" to ask Copilot to generate comments for the selected code. You can also type the comment character (```#``` in Python) where you want a comment to be, then use the autocomplete suggestions to generate a comment. You may need to experiment with different approaches to generate comments at the right level of detail for your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def rocket_velocity_change(exhaust_velocity, initial_mass, final_mass):\n",
    "    return exhaust_velocity * math.log(initial_mass / final_mass)\n",
    "\n",
    "\n",
    "def read_value(filepath, value_name):\n",
    "    with open(filepath, 'r') as f:\n",
    "        for line in f:\n",
    "            if line.startswith(value_name):\n",
    "                try:\n",
    "                    return float(line.split()[1])\n",
    "                except IndexError:\n",
    "                    raise ValueError(f'Value \"{value_name}\" was found in file \"{filepath}\" but no value was found after it')\n",
    "                except ValueError:\n",
    "                    raise ValueError(f'Value \"{value_name}\" was found in file \"{filepath}\" but the value after it was not a number')\n",
    "        else:\n",
    "            raise ValueError(f'Value \"{value_name}\" not found in file \"{filepath}\"')\n",
    "\n",
    "\n",
    "def rocket_velocity_change_from_file(filepath):\n",
    "    exhaust_velocity = read_value(filepath, 'exhaust_velocity')\n",
    "    initial_mass = read_value(filepath, 'initial_mass')\n",
    "    final_mass = read_value(filepath, 'final_mass')\n",
    "    return rocket_velocity_change(exhaust_velocity, initial_mass, final_mass)\n",
    "\n",
    "\n",
    "print(rocket_velocity_change_from_file('resources/rocket_input.txt'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improving Code\n",
    "\n",
    "You can ask Copilot to provide you with suggestions of how to improve a piece of code. You may find this easiest to do in the chat window as it makes follow-up questions easier. You could ask a general question such as \"How can I improve this code?\" or a more specific question such as:\n",
    "* \"How can I make this code more efficient?\" \n",
    "* \"How can I make this code more readable?\"\n",
    "* \"How can I split this code into smaller functions?\"\n",
    "* \"How can I make this code more robust?\"\n",
    "* \"How can I make this code more secure?\"\n",
    "* \"How can I make this function more flexible?\"\n",
    "\n",
    "If Copilot suggests changes that uses constructs or techniques you're not familiar with, you can ask for an explanation of how they work. This can be a great way to learn new programming techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_squares(lst):\n",
    "    total = 0\n",
    "    for value in lst:\n",
    "        total = total + value ** 2\n",
    "\n",
    "    return total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fixing Code\n",
    "\n",
    "Copilot can also attempt to help you fix errors in your code. You can do this by highlighting code, clicking `Ctrl + I`, and typing in ```/fix```. This will prompt Copilot to generate suggestions for fixing the selected code. You can then choose from the suggestions provided to fix the error. You can also type in a more qualitative message. Here are some tips:\n",
    "\n",
    "* If the code returns an error message, you can describe the error message in your prompt to help Copilot understand the problem.\n",
    "* If the code runs but returns the wrong output, you can describe the expected output in your prompt to help Copilot understand the problem.\n",
    "* The more you can localise the problem, the better.\n",
    "* Copilot will be better at fixing code which solves common problems as it will have seen solutions to the problem before.\n",
    "* Copilot is particularly good at suggesting fixes to syntax errors, but may struggle with more complex errors.\n",
    "* Copilot does not know what your code is supposed to do, so it may suggest inappropriate fixes.\n",
    "* If you've commented your code well and used descriptive variable names, Copilot is more likely to understand what you want your code to do and suggest appropriate fixes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_second_largest_unique_value(lst):\n",
    "    unique_values = set(lst)\n",
    "    if len(unique_values) < 2:\n",
    "    return None\n",
    "    unique_values.remove(max(unique_values))\n",
    "    return min(unique_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating Tests\n",
    "\n",
    "You can generate formal tests for piece of code by highlighting the code, pressing `Ctrl + I`, and typing in ```/tests```. This will prompt Copilot to generate tests for the selected code. Here are some tips and details:\n",
    "\n",
    "* Copilot may set up your VS Code settings to intergrate with your new tests. \n",
    "In Python, tests are normally written for functions in ```.py``` files (such as [quadratic_06a.py](quadratic_06a.py)), rather than in Jupyter notebooks.\n",
    "* As tests are normally stored in a separate file to the code they test, Copilot may suggest creating a new file. Hover over the suggested code to see where Copilot suggests the tests should go. If you have a directory for tests, you may need to move the file to the appropriate location.\n",
    "* When importing your code into the test file, you may need to adjust the import statement to match the location of the code you're testing.\n",
    "* You can ask Copilot to give you tests to match a particular testing framework such as ```unittest``` or ```pytest```. \n",
    "* Once you have some tests, you can ask for more tests to cover particular cases.\n",
    "* Copilot doesn't know what values your code should return in different cases, so it may provide tests that attempt to cover the right behaviour but with the wrong input values or expected values. You should always check the values in tests generated by Copilot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below is a poorly written Python function which intends to interpolate between two points in 2D Cartesian space and find the value at a specified value of $x$. This value of $x$ should be between the $x$ coordinates of the two points. The function should return the $y$ value at the specified $x$ value, using linear interpolation.\n",
    "\n",
    "Use Copilot to:\n",
    "* Document the code.\n",
    "* Fix any errors.\n",
    "* Generate tests for the code. You may copy this function into another file, or copy the tests into this code cell if you wish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_interpolation(x1, y1, x2, y2, x):\n",
    "    if x < x1 or x > x2\n",
    "        raise ValueError(f'x value {x} is outside the range [{x1}, {x2}]')\n",
    "\n",
    "    gradient = (y2 - y2) / (x2 - x1)\n",
    "    y_intercept = y1 - gradient * x1\n",
    "    return gradient * x + y_intercept"
   ]
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}