004_git.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/rzl-ds/gu511/blob/master/004_git.ipynb\" target=\"_parent\">\n",
    "    <img src=\"https://colab.research.google.com/assets/colab-badge.svg\"/>\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `git`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## why"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sharing code across several projects is messy. There are plenty of issues that can crop up:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "you and a teammate removed, changed, and added many different things in the same file – how do you reconcile those changes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*one person added a `scale` function:*\n",
    "\n",
    "```python\n",
    "def scale(col):\n",
    "    return (col - col.min()) / (col.max() - col.min())\n",
    "\n",
    "def process_data(df):\n",
    "    df.loc[:, 'x'] = scale(df.x)\n",
    "```\n",
    "\n",
    "*the other added a second scaling step:*\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "def process_data(df):\n",
    "    df.loc[:, 'x'] = (df.x - df.x.min()) / (df.x.max() - df.x.min())\n",
    "    df.loc[:, 'y'] = np.log1p(df.y)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "you made assumptions about how the program worked in one file and your teammate made different assumptions – now you are both developing code in different contexts. could you have avoided this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*you* assumed input features would be standardized with mean 0 and a $\\sigma$ of 1 and programmed your model contributions under that assumption\n",
    "\n",
    "*your coworker* assumed they would be winsorized and then min-max scaled 0 to 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "you made changes to your project that the client didn't like and they want to \"go back to how it was on Monday\" – how do you go back?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "uh.... why is almost everything getting scored above 50% risky all of a sudden?!? the board is gonna lose it.\n",
    "\n",
    "```python\n",
    "# this is an incredibly skewed distribution and dividing\n",
    "# by the mean was a bad idea, divide by the median instead\n",
    "#df.x = df.x / df.x.mean()\n",
    "df.x = df.x / df.x.median()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "you want to try out something that may be a total failure without ruining the production codebase – how do you experiment?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    "# what if it's a deep neural net but I make the activation\n",
    "# functions ALSO be deep neural nets\n",
    "# it's 4AM but I'm pretty sure this is genius\n",
    "layer = tf.keras.Dense(10000, activation=netception)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**<div align=\"center\">the ultimate reason: you are *going* to use it and people will *want* you to use it</div>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## what"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**\"Version Control\"** is the general concept of addressing the above issues (and more) in a systematic way -- a type of discipline or philosophy to help us develop code either on our own or collaboratively while also avoiding the above pitfalls."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**`git`** is one of several industry-standard tools used to implement the practice of version control in real development environments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "under the hood, `git` is a command-line tool which implements a graph-based approach to tracking different versions of files and the pathways (edits) from one version to the next.\n",
    "\n",
    "<br><img width=\"1000px\" src=\"https://miro.medium.com/max/552/1*PiduCtSA7kMwdPiMZo1nHw.jpeg\"></img>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "thinking of the edit history of files as directed graphs from one \"snapshot\" to the next allows us to consider both\n",
    "\n",
    "1. the history of a given version of the file (all the changes that were made to \"get to now\")\n",
    "1. other paths / parallel work done by multiple people (different \"branches\" of the \"tree\" of changes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "the various commands and subcommands associated with the main command `git` (e.g. `add`, `commit`, `merge`, `checkout`, `push`, `pull`; more details below) are all meant to be isolated, atomic ways of saying exactly what we're doing when we update code, specifically so that we can avoid the pitfalls mentioned above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*short-term*: `git` is confusing! it's a new way of approaching collaboration, and it's easy to mess up."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*long-term*: the benefits are immense. the more people we have working on a project and the more often we are working together and independently, the more crucial `git` becomes to enforcing group communication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### one important distinction: local VC vs. remote VC\n",
    "\n",
    "there is one distinction which I personally think is subtle but very valuable, so let's start with it: there are two different contexts for version control\n",
    "\n",
    "**local** vs. **remote** version control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### local\n",
    "\n",
    "I, as a standalone developer, may want to use git on my own projects. problems 3 and 4 in the WHY section above (rolling back changes or tracking development changes) are both issues that occur even without collaboration. this is really where \"version\" is coming from – I want the ability to control the version of the code I have written, to create new versions and to move between old and new versions easily and with confidence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "common local-specific commands\n",
    "\n",
    "+ `add`\n",
    "+ `commit`\n",
    "+ `merge`\n",
    "+ `branch`\n",
    "+ `checkout`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### remote\n",
    "\n",
    "in addition to my personal code development, I might be collaborating as well. This is where problems 1 and 2 in the WHY section above (miscommunication due to simultaneous editing / not sharing full context) crop up. `git` gives us a way of communicating exactly what we changed and how, and formalizing the process of combining changes made by more than one person and communicating changes to a large group of people"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "common remote-specific commands\n",
    "\n",
    "+ `fetch`\n",
    "+ `pull`\n",
    "+ `push`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "advanced: technically, `pull` is a shorthand for the remote-only `fetch` and the local-only `merge`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## how\n",
    "\n",
    "the best way to demonstrate how we use `git` is to actually use a couple of commands on a toy project. let's work on an important new Storyblocks project called"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<div align=\"center\"><h2><code>tacoworld</code></h2></div><br>\n",
    "\n",
    "<br><div align=\"center\"><img src=\"https://pbs.twimg.com/media/CpbLuCeWIAAMxSb.jpg:large\" width=\"800\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "if you want to follow along, all you need to do is get into an environment where you have `git` installed. options:\n",
    "\n",
    "1. log in to your `ec2` instance (the demo is tested for this option)\n",
    "1. open the `terminal` app on your `mac` laptop\n",
    "1. open `git` `bash` on your `windows` laptop\n",
    "\n",
    "then, at the command line, enter:\n",
    "\n",
    "```sh\n",
    "mkdir -p ~/code/tacoworld\n",
    "cd ~/code/tacoworld\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I have crafted an amazing `python` script which predicts what my coworkers and I want for lunch. I have written my code to a file called `tacoworld.py` and placed it in its own `tacoworld` directory:\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1ELbVinyk99LVPQ7U96pXTv0gqL2RvRVr\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "the code itself is proprietary and extremely advanced, so please do not share it beyond this class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "file name: `tacoworld.py`\n",
    "\n",
    "```python\n",
    "print(\"I want tacos!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "for those following along at home, create your own `tacoworld.py` with:\n",
    "\n",
    "```sh\n",
    "echo 'print(\"I want tacos!\")' > tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git init`\n",
    "\n",
    "I want to make sure that as I make improvements I can keep track of versions.\n",
    "\n",
    "I know I will use `git` to do this, so the very first thing I want to do is make sure `git` knows I want to track what's going on in `tacoworld`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I change directories into the `tacoworld` directory, and I use the `git` command line client to initialize my `git` repo:\n",
    "\n",
    "```sh\n",
    "cd ~/code/tacoworld\n",
    "git init\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Initialized empty Git repository in ~/code/tacoworld/.git/\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*Note: you will only have to do this if you are starting from scratch – more often than not, you will be cloning – see below.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### git status\n",
    "\n",
    "`git` is happy to tell me what changes it believe have been made to my files since I started my repository, and it does so via the command\n",
    "\n",
    "```sh\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "\n",
    "No commits yet\n",
    "\n",
    "Untracked files:\n",
    "  (use \"git add <file>...\" to include in what will be committed)\n",
    "\n",
    "        tacoworld.py\n",
    "\n",
    "nothing added to commit but untracked files present (use \"git add\" to track)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There's a bit to unpack here, so line by line:\n",
    "\n",
    "```\n",
    "On branch master\n",
    "```\n",
    "\n",
    "this means I am currently looking at a *branch* of the graph (will define later) called \"master\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "\n",
    "No commits yet\n",
    "```\n",
    "\n",
    "I haven't told `git` to record (commit) any changes I've made to my code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "\n",
    "No commits yet\n",
    "\n",
    "Untracked files:\n",
    "  (use \"git add <file>...\" to include in what will be committed)\n",
    "\n",
    "        tacoworld.py\n",
    "```\n",
    "\n",
    "this heading indicates that `git` is about to list some files it has never yet seen, and if you want to record changes, you will need to \"add\" those files with the `git add` command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "\n",
    "No commits yet\n",
    "\n",
    "Untracked files:\n",
    "  (use \"git add <file>...\" to include in what will be committed)\n",
    "\n",
    "\ttacoworld.py\n",
    "\n",
    "nothing added to commit but untracked files present (use \"git add\" to track)\n",
    "```\n",
    "\n",
    "finally, one last summary statement: there's nothing to commit, but also maybe something you *should* commit, nudge nudge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git add`\n",
    "\n",
    "`git` said we should add so let's add!\n",
    "\n",
    "to return to the \"discipline\" aspect of version control, this is a formal statement that I would like to put *something* into the list of changes I am making to my files. I'm not making this an \"official\" `git`-tracked change; I'm just getting ready to do it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "again, using the command line:\n",
    "\n",
    "```sh\n",
    "git add tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`git` itself won't say anything about this change, but it will tell you something new and different if you ask for the status again\n",
    "\n",
    "```sh\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "\n",
    "No commits yet\n",
    "\n",
    "Changes to be committed:\n",
    "  (use \"git rm --cached <file>...\" to unstage)\n",
    "\n",
    "         new file:   tacoworld.py\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`tacoworld.py` was previously \"untracked\" and is now listed as a \"new file\" with \"changes to be committed\" -- that's about right."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*advanced*: for future `git add` calls, I may decide to use a flag: `-p` or `--patch` to \"pick\" \"patches\" of changes. this allows me to see what exactly changed and decide whether or not I want to add that change to my current snapshot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git commit`\n",
    "\n",
    "you may think we're done now, but actually we're only halfway. `git` separates out the act of declaring what changes you make (`git add`) from the act of officially recording them as a \"change\" to the code base (`git commit`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "a useful analogy: think of the process of painting a still-life painting. before you can paint the picture, you have to assemble the pieces you want to paint.\n",
    "\n",
    "\n",
    "<br><div align=\"center\"><img src=\"https://upload.wikimedia.org/wikipedia/commons/8/8a/Willem_Claesz._Heda_-_Still-Life_with_Pie%2C_Silver_Ewer_and_Crab_-_WGA11248.jpg\" width=\"500\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "a useful analogy: think of the process of painting a still-life painting. before you can paint the picture, you have to assemble the pieces you want to paint.\n",
    "\n",
    "\n",
    "<br><div align=\"center\"><img src=\"https://cdn.shopify.com/s/files/1/0817/6361/products/01062-Still_20Life_20With_20Pink_20Vase_large.jpeg?v=1465396397\" width=\"500\"></div>\n",
    "<em><div align=\"center\">quality of portrait may vary</div></em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we've added all the pieces we wanted to keep track of -- let's make it facebook official. let's `commit` them.\n",
    "\n",
    "in doing this, we are creating a *snapshot* of the code at a certain point in time (literally: we are saving a real copy of any new or changed files every time we `commit`).\n",
    "\n",
    "from now on, no matter what we do we will always be able to get back to this point in the history of the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we'll add a \"commit message\" -- a short text summary of what we changed -- with the `-m` (`--message`) flag\n",
    "\n",
    "```sh\n",
    "git commit -m 'tacoworld: initial commit'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "[master (root-commit) 14caba7] tacoworld: initial commit\n",
    " 1 file changed, 3 insertions(+)\n",
    " create mode 100644 tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*note*: if you received the following:\n",
    "\n",
    "```\n",
    " Committer: Ubuntu <ubuntu@ip-172-31-76-204.ec2.internal>\n",
    "Your name and email address were configured automatically based\n",
    "on your username and hostname. Please check that they are accurate.\n",
    "You can suppress this message by setting them explicitly. Run the\n",
    "following command and follow the instructions in your editor to edit\n",
    "your configuration file:\n",
    "\n",
    "    git config --global --edit\n",
    "\n",
    "After doing this, you may fix the identity used for this commit with:\n",
    "\n",
    "    git commit --amend --reset-author\n",
    "```\n",
    "\n",
    "go ahead and run those two `git config` commands. the first will allow you to updating to use your real email address and name; the second will fix the commit you just made to include that info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we can verify that we're \"current\" with a call to `git status`:\n",
    "\n",
    "```sh\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "nothing to commit, working tree clean\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### another cycle: edit, `git status`, `git add`, `git status`, `git commit`\n",
    "\n",
    "let's put this all together for a full development cycle. we know we're current (just checked). let's edit our file!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "suppose I make a change to `tacoworld.py` to be a bit bolder:\n",
    "\n",
    "```python\n",
    "print(\"I, Zach Lamberty, want tacos!!\")\n",
    "```\n",
    "\n",
    "*for those following along, run:*\n",
    "\n",
    "```sh\n",
    "echo 'print(\"I, Zach Lamberty, want tacos!\")' > tacoworld.py\n",
    "```\n",
    "\n",
    "*feel free to use your own name*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`type type type type... save`. now that I've saved those changes, and now I want to know what `git` sees.\n",
    "\n",
    "```sh\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "Changes not staged for commit:\n",
    "  (use \"git add <file>...\" to update what will be committed)\n",
    "  (use \"git checkout -- <file>...\" to discard changes in working directory)\n",
    "\n",
    "\tmodified:   tacoworld.py\n",
    "\n",
    "no changes added to commit (use \"git add\" and/or \"git commit -a\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "in particular, note that `new file` was replaced with `modified` (we're tracking changes, and saw one!), and that we have a new message about using `git checkout` to discard those changes and revert to our last saved state -- not bad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "let's add that change -- this time using the `-p` flag to \"pick\" \"patches\" of changes (you can skip this by *not* providing the flag)\n",
    "\n",
    "```sh\n",
    "git add -p tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index 77e8759..214d68d 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1 +1 @@\n",
    "-print(\"I want tacos!\")\n",
    "+print(\"I, Zach Lamberty, want tacos!\")\n",
    "Stage this hunk [y,n,q,a,d,/,e,?]? y\n",
    "```\n",
    "\n",
    "(press `y` to \"stage this hunk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "again, checking to see what `git` sees\n",
    "\n",
    "```sh\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "Changes to be committed:\n",
    "  (use \"git reset HEAD <file>...\" to unstage)\n",
    "\n",
    "        modified:   tacoworld.py\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "and `commit`-ing those changes:\n",
    "\n",
    "```sh\n",
    "git commit -m 'tacoworld: my name is Zach and I do not fear my hunger'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "[master b115876] tacoworld: my name is Zach and I do not fear my hunger\n",
    " 1 file changed, 1 insertion(+), 1 deletion(-)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "let's go back to that middle stage where we called `git add` with the extra `-p` flag:\n",
    "\n",
    "```sh\n",
    "git add -p tacoworld.py\n",
    "```\n",
    "\n",
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index 77e8759..214d68d 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1 +1 @@\n",
    "-print(\"I want tacos!\")\n",
    "+print(\"I, Zach Lamberty, want tacos!\")\n",
    "Stage this hunk [y,n,q,a,d,/,e,?]? y\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "this jumbly bunch of text and symbols is a very compact way of isolating what *really* changed from one version of `tacoworld.py` to the next.\n",
    "\n",
    "`git` is engineered to compare the last recorded version of the code to the current state and calculate the `diff`s: standardized text representations of changes, additions, and deletions to lines in the now-edited files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index 77e8759..214d68d 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1 +1 @@\n",
    "-print(\"I want tacos!\")\n",
    "+print(\"I, Zach Lamberty, want tacos!\")\n",
    "Stage this hunk [y,n,q,a,d,/,e,?]? y\n",
    "```\n",
    "\n",
    "`git` noticed that the original version of line 1 in my old file `print(\"I want tacos!\")` changed into a different string in the new file `print(\"I, Zach Lamberty, want tacos!\")`.\n",
    "\n",
    "`git` asked if I wanted to include this change (`Stage this hunk?`) and I said that `y`es I did want to add that change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git log`\n",
    "\n",
    "we've now made two `commi`s to our `git` repository. I told you that one reason to use version control is to have a running list of the changes we've made to our files; how do we see that list?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`git` records a history of changes to files there is a `git log` -- a history of all the batches of changes we've ever recorded. changes to files are listed in a newest-to-oldest order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git log\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "commit 6e98be1fea823072757cbec7b7d2a020cafcc85b (HEAD -> master)\n",
    "Author: Ubuntu <ubuntu@ip-172-31-76-204.ec2.internal>\n",
    "Date:   Tue Sep 15 00:59:54 2020 +0000\n",
    "\n",
    "    tacoworld: my name is Zach and I do not fear my hunger\n",
    "\n",
    "commit 0041239d2516b97dd8d3e5e1b83a4093deccbd97\n",
    "Author: Ubuntu <ubuntu@ip-172-31-76-204.ec2.internal>\n",
    "Date:   Tue Sep 15 00:58:39 2020 +0000\n",
    "\n",
    "    tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "this log message is a collection of different `commit`s represented as a block of text. each block of text contains\n",
    "\n",
    "1. the `commit` `sha`: this is a unique 40-digit character string that is the [`SHA-1` hash](https://en.wikipedia.org/wiki/SHA-1) of the current state of the file (there is a lot of hand waving here)\n",
    "    + basically, think of this as a unique lookup key that `git` has associated with that state in time\n",
    "1. metadata: the author and date information for the commit\n",
    "1. message: the message I recorded when I added that commit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "generally, that command is overkill and we really only one one line of information. you'll never guess what the flag is that gives us only one line of information...\n",
    "\n",
    "also, I'll add the `--decorate` flag because it adds some information that is frequently useful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```sh\n",
    "git log --oneline --decorate\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "6e98be1 (HEAD -> master) tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "there is also a super crazy long command that I have recorded permanently as a fancy alias (see the \"advanced topics\" below):\n",
    "\n",
    "```sh\n",
    "git log --graph --abbrev-commit --decorate --date=relative --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(bold white)%s%C(reset) - %C(red)%an%C(reset)%C(bold yellow)%d%C(reset)' --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "* 6e98be1 - (39 seconds ago) tacoworld: my name is Zach and I do not fear my hunger - Ubuntu (HEAD -> master)\n",
    "* 0041239 - (2 minutes ago) tacoworld: initial commit - Ubuntu\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To be honest, I pretty much never use the basic `git log`, I only use the alias for that long command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `HEAD -> master`\n",
    "\n",
    "you may have noticed that in all of the `git log` commands above there was the text\n",
    "\n",
    "```\n",
    "(HEAD -> master)\n",
    "```\n",
    "\n",
    "one quick note on this: `git` uses a special human-readable set of tags to describe some of those `SHA` values. in particular, `HEAD` and `master` are two of those tags.\n",
    "\n",
    "we will revisit these in `git branch` below when it will hopefully make more sense why these tags are useful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### quick summary of \"local\" commands\n",
    "\n",
    "so far we've done all our work on our local computer, and we could keep going like this forever:\n",
    "\n",
    "+ `git init`\n",
    "\n",
    "then we loop through the following:\n",
    "\n",
    "+ edit code\n",
    "+ `git status`\n",
    "+ `git add`\n",
    "+ `git commit`\n",
    "\n",
    "and also, `git log` if we want history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**<div align=\"center\">PAUSE FOR ZOOM BREAK</div>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### sharing with the world: `github`\n",
    "\n",
    "`git` is very useful for monitoring your own code's version history, but it becomes invaluable when you are working with others. rather than go through the complicated back-and-forth of explaining what changed and how, let `git` handle it for you!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "in order to share code, we need to put it in some shared place (the jargon: we need a mutually accessible file share for our `bare` repositories).\n",
    "\n",
    "fortunately, there are well-excepted tools for doing exactly this. the primary ones:\n",
    "\n",
    "+ [`github`](https://github.com/)\n",
    "+ [`gitlab`](https://about.gitlab.com/)\n",
    "+ [`bitbucket`](https://bitbucket.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "let's use `github`! it's free and hosted for us and why not?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "you all created `github` accounts for a previous homework, so go to https://github.com and log in.\n",
    "\n",
    "once logged in, click on the plus sign in the top right menu bar and select \"new repository\"\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=13w1X-pialhgAkGBH7sak2FS4FnLlLOCh\" width=\"600\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1Zj0IUYuFgvt_339uM8UAPkUnxDZeFdt5\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**copy, but don't paste!!**\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1_V2LmtLOUdSHBCAlKE7r1GRvj6GlJ_h4\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "at this point we have created a *place* where we could share our code with the world. the commands we just copied are the commands that will actually share it.\n",
    "\n",
    "rather than just copy/paste-ing that, let's talk about what those commands are doing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git remote`\n",
    "\n",
    "we use the `git remote` command to formally declare a \"remote\" place we would like to publish our code (to have an independent backup? to share? whatever the reason!). along the way, we give it a short nickname -- the default is \"origin\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "remember: at the top of that `github` page there was a toggle button to switch between `https` and `ssh`. those two options correspond to two different ways of communicating with `github`. depending on which we would have selected, we'd have two different `git remote` commands:\n",
    "\n",
    "```sh\n",
    "git remote add origin https://github.com/RZachLamberty/tacoworld.git\n",
    "git remote add origin git@github.com:RZachLamberty/tacoworld.git\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "the only difference is the connection url, and depending on which we choose we will have a different authentication scheme when we try to talk to `github`:\n",
    "\n",
    "| url | protocol | authentication method |\n",
    "|-|-|-|\n",
    "| `https://github.com/RZachLamberty/tacoworld.git` | `https` | `github` user name and password login (every time!) |\n",
    "| `git @github.com:RZachLamberty/tacoworld.git` | `ssh` | `ssh` public / private key exchange |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "head on back over to the command line and enter the first of those three commands (for `ssh` access):\n",
    "\n",
    "```sh\n",
    "git remote add origin git@github.com:RZachLamberty/tacoworld.git\n",
    "```\n",
    "\n",
    "now, whenever you write \"origin\", `git` knows to look to your `github` repo. cool."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "that's only part of the battle, though -- we've told `git` what url to look at when we want to talk using `ssh`, but what are the other two things we always have to provide (in addition to `url`) to talk via `ssh`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "1. username (assumed by `github` to be any one of the users who own the project)\n",
    "1. **authentication** in the form of a public / private key exchange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### adding an `ssh` key to your `github` account\n",
    "\n",
    "in order to `push` code from your local machine (your laptop) to `github`, you need to give `github` your public (***NOT PRIVATE***) key.\n",
    "\n",
    "first, let's determine whether or not you have a key pair. on our `ec2` instance, type:\n",
    "\n",
    "```sh\n",
    "ls ~/.ssh/id_rsa*\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "if you got a pair of file names, sit tight.\n",
    "\n",
    "if instead you received a \"no such file or directory\" error, let's *create* a key pair on our `ec2` instance. start with\n",
    "\n",
    "```sh\n",
    "ssh-keygen -t rsa -b 4096 -C <YOUR GU ID>@georgetown.edu\n",
    "```\n",
    "\n",
    "and keep pressing `enter` until you're done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "now everyone should be able to enter the following command and have the public key printed to the screen:\n",
    "\n",
    "```sh\n",
    "cat ~/.ssh/id_rsa.pub\n",
    "```\n",
    "\n",
    "go ahead and copy that. then do steps 2 - 8 of [this walkthrough](https://help.github.com/articles/adding-a-new-ssh-key-to-your-github-account/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "so we did that...\n",
    "\n",
    "can anyone take a step back here and remind us *why* we did that? what are we doing right now?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git push`\n",
    "\n",
    "way way back, `github` asked us to run the following commands:\n",
    "\n",
    "```sh\n",
    "git remote add origin git@github.com:RZachLamberty/tacoworld.git\n",
    "git branch -M master\n",
    "git push -u origin master\n",
    "```\n",
    "\n",
    "we already ran `git remote` and explained what that command is doing, and *also* added `ssh` keys to our `github` profile so that we are allowed to talk to that particular url (`git@ github.com:<user name>/tacoworld.git`) as a `remote`. now, it's time to `push`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git branch -M master\n",
    "```\n",
    "\n",
    "we'll talk about branches later, but this is a line added to make sure that whatever you are adding is on a branch called `master`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git push -u origin master\n",
    "```\n",
    "\n",
    "1. the `-u` flag is setting an \"upstream\" -- don't worry about this just yet\n",
    "1. we specifically tell `git` to use the `remote` nicknamed `origin` we created above. this would have happened by default for reasons we will get into later\n",
    "1. the \"branch\" name `git` should use is `master` -- more on this later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "if this is the first time you're connecting to a `gitub` server from this instance using `ssh` (that's what we're doing, remember, with the `ssh:` remote origin), you will get that old familiar fingerprint check:\n",
    "\n",
    "```\n",
    "The authenticity of host 'github.com (140.82.114.4)' can't be established.\n",
    "RSA key fingerprint is SHA256:nThbg6kXUpJWGl7E1IGOCspRomTxdCARLviKw6E5SY8.\n",
    "Are you sure you want to continue connecting (yes/no)? yes\n",
    "```\n",
    "\n",
    "go ahead and say yes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "if everything went according to plan:\n",
    "\n",
    "```\n",
    "Counting objects: 6, done.\n",
    "Compressing objects: 100% (2/2), done.\n",
    "Writing objects: 100% (6/6), 550 bytes | 550.00 KiB/s, done.\n",
    "Total 6 (delta 0), reused 0 (delta 0)\n",
    "To github.com:RZachLamberty/tacoworld.git\n",
    " * [new branch]      master -> master\n",
    "Branch 'master' set up to track remote branch 'master' from 'origin'.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "go back to your browser with those commands we copied and refresh\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=16zJp6aN4NsdrX9FcY7HHa3l3eeZahXLD\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "in particular, go check out that \"commits\" link:\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1ABZ6xCGTuhjSH_Qayblt3Gku17OcVjZb\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### summary on *establishing* a `remote`\n",
    "\n",
    "the `ssh` key setup process we just went through is something that has to happen *once* for *each laptop* you want to use. your public and private key uniquely identify you on that machine.\n",
    "\n",
    "the `github` interface \"plus button\" repo creation step as well as the copied commands:\n",
    "\n",
    "```sh\n",
    "git remote add origin git@github.com:RZachLamberty/tacoworld.git\n",
    "git branch -M master\n",
    "git push -u origin master\n",
    "```\n",
    "\n",
    "happen *once* for *each* new repo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### collaboration using official `github` collaborators\n",
    "\n",
    "using `github`, there are a few ways to collaborate. the first we'll talk about -- and the one that is closer to how non-`github` implementations of `git` remote repositories work -- is by adding other users as \"collaborators\" to this specific repo (the other is via forks and pull requests; we'll talk about that below).\n",
    "\n",
    "but for now, collaborators:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I posted the preliminary findings of my predictive model and the DC data science community is buzzing.\n",
    "\n",
    "in particular, my son Eamon is interested and wants to collaborate. I add him as a collaborator on my repository:\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1TwrmqqP64OvN2lrLO_OiQMLXi31gaLL1\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git clone`\n",
    "\n",
    "the first thing he does as a collaborator is get a *local* copy on his laptops of the shared *remote* repository on `github`. he does this using `git clone` and the url from before (he gets this via `github`).\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1EMhdQ1fZHyhI7vrbRMgrn9kg5lAGjeSR\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "then, at the command line he types:\n",
    "\n",
    "```sh\n",
    "git clone https://github.com/RZachLamberty/tacoworld.git\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Cloning into 'tacoworld'...\n",
    "remote: Counting objects: 6, done.\n",
    "remote: Compressing objects: 100% (2/2), done.\n",
    "remote: Total 6 (delta 0), reused 6 (delta 0), pack-reused 0\n",
    "Unpacking objects: 100% (6/6), done.\n",
    "Checking connectivity... done.\n",
    "```\n",
    "\n",
    "this creates a local directory named `tacoworld` and downloads the `git` history, then builds the current version of the files inside that directory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Eamon is hungry too: edit, `git status`, `git add`, `git commit`, `git push`\n",
    "\n",
    "My son Eamon wants to make his preferences known, so he repeats the `git` version update cycle. he makes his changes to the file:\n",
    "\n",
    "```python\n",
    "# file name: tacoworld.py\n",
    "\n",
    "print(\"I, Zach Lamberty, want tacos!!\")\n",
    "print(\"I, Eamon Lamberty, want tacos!!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "On branch master\n",
    "Your branch is up-to-date with 'origin/master'.\n",
    "Changes not staged for commit:\n",
    "  (use \"git add <file>...\" to update what will be committed)\n",
    "  (use \"git checkout -- <file>...\" to discard changes in working directory)\n",
    "\n",
    "\tmodified:   tacoworld.py\n",
    "\n",
    "no changes added to commit (use \"git add\" and/or \"git commit -a\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git add -p\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index 214d68d..1a0db65 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1 +1,2 @@\n",
    " print(\"I, Zach Lamberty, want tacos!\")\n",
    "+print(\"I, Eamon Lamberty, want tacos!\")\n",
    "Stage this hunk [y,n,q,a,d,/,e,?]? y\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git commit -m 'tacoworld: goo goo ga ga'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "[master 9c55fa3] tacoworld: goo goo ga ga\n",
    " 1 file changed, 1 insertion(+)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### another `git push`\n",
    "\n",
    "Eamon is proud of his work and wants to share it with the team. the way he does that is by pushing those changes to the shared repository. `git push` takes the log of individual file changes (the \"commit log\", the `diff`s we saw when we ran `git add -p`) and updates the remote (shared) log with those changes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git push origin master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Counting objects: 3, done.\n",
    "Compressing objects: 100% (2/2), done.\n",
    "Writing objects: 100% (3/3), 330 bytes | 0 bytes/s, done.\n",
    "Total 3 (delta 0), reused 0 (delta 0)\n",
    "To https://github.com/RZachLamberty/tacoworld.git\n",
    "   b115876..9c55fa3  master -> master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "and check out `github` after that\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1wru9T2hy9hqSZJGAyegl0kFPoIrcwVdN\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "so far we've discussed two ways of *initializing* a repository on your local laptop:\n",
    "\n",
    "1. `git init` to \"start from local\", i.e. create your own from scratch, and\n",
    "2. `git clone` to \"start from remote\", i.e. download a repository someone else already started and shared on a remote like `github`\n",
    "\n",
    "we also have discussed a way to *add* changes (`commit`s) to those repositories once you have them: `git push`\n",
    "\n",
    "we *haven't* talked about how to *GET* changes other people have made to shared repositories."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git pull`\n",
    "\n",
    "the opposite of `push` is `pull`, and that's what we will use to download updates our collaborators have added to our shared `github` repo.\n",
    "\n",
    "in this case I happen to *know* Eamon made the last updates, so I need to update my local version to incorporate his changes. I won't always know when changes have been made, but that doesn't have to affect my workflow -- that's the point of using `git`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "# note: I don't have to write out all of\n",
    "#   git pull origin master.\n",
    "# I could, but both of the \"origin master\" values\n",
    "# are assumed by default\n",
    "git pull\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "remote: Enumerating objects: 5, done.\n",
    "remote: Counting objects: 100% (5/5), done.\n",
    "remote: Compressing objects: 100% (2/2), done.\n",
    "remote: Total 3 (delta 0), reused 3 (delta 0), pack-reused 0\n",
    "Unpacking objects: 100% (3/3), done.\n",
    "From github.com:RZachLamberty/tacoworld\n",
    "   6e98be1..1d12ddf  master     -> origin/master\n",
    "Updating 6e98be1..1d12ddf\n",
    "Fast-forward\n",
    " tacoworld.py | 1 +\n",
    " 1 file changed, 1 insertion(+)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "under the hood, `git pull` is doing two things:\n",
    "\n",
    "1. it downloads the current state of the `remote` (this is `git fetch`, which downloads the current remote `master` state to `origin/master`)\n",
    "1. it incorporates the changes that have been made to `master` in that `remote` to your current `master` (`git merge origin/master`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we can verify that the code I have includes Eamon's changes:\n",
    "\n",
    "```sh\n",
    "cat tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "print(\"I, Zach Lamberty, want tacos!\")\n",
    "print(\"I, Eamon Lamberty, want tacos!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### making changes\n",
    "\n",
    "having just run `git pull`, I know that my local state is current.\n",
    "\n",
    "I want to make some changes, so I follow the same workflow:\n",
    "\n",
    "1. edit\n",
    "1. `git add`\n",
    "1. `git commit`\n",
    "1. `git push`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I edit my `tacoworld.py` file to make sure that everyone understands my full commitment to and trust in my predictive model. the new version is:\n",
    "\n",
    "```python\n",
    "print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    "print(\"I, Eamon Lamberty, want tacos!!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git add -p\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index a5260fa..e79a838 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1,2 +1,2 @@\n",
    "-print(\"I, Zach Lamberty, want tacos!\")\n",
    "+print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    " print(\"I, Eamon Lamberty, want tacos!!\")\n",
    "Stage this hunk [y,n,q,a,d,e,?]? y\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git commit -m 'tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git push\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Counting objects: 3, done.\n",
    "Compressing objects: 100% (2/2), done.\n",
    "Writing objects: 100% (3/3), 389 bytes | 389.00 KiB/s, done.\n",
    "Total 3 (delta 0), reused 0 (delta 0)\n",
    "To github.com:RZachLamberty/tacoworld.git\n",
    "   1d12ddf..dad7986  master -> master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "and lo!\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1iXooCL8O_aV_Vkk0l6cPnoT1g7lnZLEJ\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**<div align=\"center\">PAUSE FOR ZOOM BREAK</div>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### keep on' summarizing\n",
    "\n",
    "so we have talked about how to track changes locally:\n",
    "\n",
    "1. `git init` to create a repo\n",
    "1. `git add` and `git add -p` to *stage* changes\n",
    "1. `git commit` and `git commit -m` to *commit* changes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "and we have also talked about how to communicate those changes with the outside world\n",
    "\n",
    "1. `git remote add` and `git remote -v` to add or list shared \"remote\" repositories\n",
    "1. `git clone` to initially download the current state of a shared repository\n",
    "1. `git pull` to pull down (download) *changes* other people have recorded in the shared repository\n",
    "1. `git push` to push up (upload) *changes* you have recorded in the shared repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git checkout`\n",
    "\n",
    "we call it version *control*, not version *tracking* -- this implies that we should be able to not only record what's changed, but actually \"move around\" to different points in the code history.\n",
    "\n",
    "well, we can, using the command `git checkout`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "right now, `tacoworld.py` looks like:\n",
    "\n",
    "```sh\n",
    "cat tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```py\n",
    "print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    "print(\"I, Eamon Lamberty, want tacos!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "suppose we want to \"go back\" to the code before Eamon tried to show off about how much he likes tacos when it was *MY* idea in the first place.\n",
    "\n",
    "to start, let's look at the history of changes so far:\n",
    "\n",
    "```sh\n",
    "git log --oneline\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "dad7986 (HEAD -> master, origin/master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "currently there are two tags `master` and `origin/master` which are associated with `sha` `7241432`. these are just human-readable aliases for that 40-character `sha` string.\n",
    "\n",
    "there is also a special tag called `HEAD` which is telling me that my current \"working state\" is at `7241432` as well.\n",
    "\n",
    "`HEAD` can move around in this log!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I want to go back before Eamon ruined things. the last state I liked was `6e98be1` we can `checkout` that point in time using `git checkout`:\n",
    "\n",
    "```sh\n",
    "# use your own sha values if you're following\n",
    "git checkout 6e98be1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Note: checking out '6e98be1'.\n",
    "\n",
    "You are in 'detached HEAD' state. You can look around, make experimental\n",
    "changes and commit them, and you can discard any commits you make in this\n",
    "state without impacting any branches by performing another checkout.\n",
    "\n",
    "If you want to create a new branch to retain commits you create, you may\n",
    "do so (now or later) by using -b with the checkout command again. Example:\n",
    "\n",
    "  git checkout -b <new-branch-name>\n",
    "\n",
    "HEAD is now at 6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "look at the log again, this time throwing in the `--all` flag:\n",
    "\n",
    "```sh\n",
    "git log --oneline --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "dad7986 (origin/master, master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 (HEAD) tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "finally, look at the file:\n",
    "\n",
    "```sh\n",
    "cat tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```py\n",
    "print(\"I, Zach Lamberty, want tacos!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "just like old times!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "so, I've taken a few minutes to think things over and I've decided that *maybe* I overreacted. let's go back to the current state I shared with everyone already:\n",
    "\n",
    "```sh\n",
    "# when you have a tag, you can use that instead of the sha!\n",
    "git checkout master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Previous HEAD position was 6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "Switched to branch 'master'\n",
    "Your branch is up to date with 'origin/master'.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git log --oneline\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "dad7986 (HEAD -> master, origin/master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `git branch`\n",
    "\n",
    "sometimes you want to make changes but you want to keep them apart from the main code base\n",
    "\n",
    "1. experiments that you want to *track* but might not think are keepers (a new modelling technique you haven't tried before)\n",
    "1. features that will require a lot of time or effort and the code will work fine without them (e.g. adding an ensemble method, or a faster ETL process)\n",
    "1. your team has separated out the development work into teams and your team is focused on one set of code changes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "in situations like this, you may want to create a `branch`. this is a separately recorded set of changes -- a new \"branch\" in the \"tree\" of changes.\n",
    "\n",
    "up until now, we've done everything in linear order, so this \"tree\" has been very boring -- just straight up, one list of sequential commits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "one day I peaked out the windows and -- folks --\n",
    "\n",
    "<div align=\"center\"><h2>a challenger approaches</h2></div><br>\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://nebula.wsimg.com/55172a3ebc05eb20813565186dc56825?AccessKeyId=036259FD3A79DC4CD9B5&disposition=0&alloworigin=1\" width=\"700\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "what happens if, some day, I'm tired of tacos and this wicked wagon shows up? the model must be updated to incorporate this new information. I think a `branch` is in order\n",
    "\n",
    "we start by creating a new `branch` -- this is a formal declaration to `git` that we are going to create a new path to track. `git` will save this path separately"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "# otr = over the rice\n",
    "git branch otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "first, let's note that this just *creates* the `branch` and doesn't do anything else:\n",
    "\n",
    "```sh\n",
    "# with no argument, it lists:\n",
    "git branch\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "* master\n",
    "  otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "furthermore, the output of `git log` tells us that `otr` is \"at the same point\" in the edit history as `master` and `origin/master`:\n",
    "\n",
    "```sh\n",
    "git log --oneline\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "dad7986 (HEAD -> master, origin/master, otr) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "our `HEAD` tag (which represents our current working state in the edit history) is pointing at the `master` tag.\n",
    "\n",
    "well guess what?\n",
    "\n",
    "**`master` was a `branch` all along**\n",
    "\n",
    "`master` is the default `branch`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "switching to a different branch is done using `git checkout` (the command we used before to move to different points in the `master` branch / code edit history).\n",
    "\n",
    "```sh\n",
    "git checkout otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Switched to branch 'otr'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "note that `HEAD` is pointing at our `otr` branch tag now too:\n",
    "\n",
    "```sh\n",
    "git log --oneline --decorate\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "dad7986 (HEAD -> otr, origin/master, master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "note the before / after difference:\n",
    "\n",
    "```\n",
    "# before\n",
    "dad7986 (HEAD -> master, origin/master, otr) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "\n",
    "# after\n",
    "dad7986 (HEAD -> otr, origin/master, master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we have now:\n",
    "\n",
    "+ created an isolated new place to track changes\n",
    "    + named it something related to our \"feature\"\n",
    "+ checked it out\n",
    "\n",
    "from here, we can repeat the same old development cycle (edit, `add`, `commit`, `push`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I edit the file to read:\n",
    "\n",
    "```python\n",
    "print(\"Today, actually, I (Zach Lamberty), want OTR!\")\n",
    "print(\"I, Eamon Lamberty, want tacos!!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I add the changes:\n",
    "\n",
    "```sh\n",
    "git add -p\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index e79a838..a10a405 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1,2 +1,2 @@\n",
    "-print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    "+print(\"Today, actually, I (Zach Lamberty), want OTR!\")\n",
    " print(\"I, Eamon Lamberty, want tacos!!\")\n",
    "Stage this hunk [y,n,q,a,d,e,?]? y\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I commit the changes:\n",
    "\n",
    "```sh\n",
    "git commit -m 'otr: what happens when over the rice is here?'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "[otr 37a75a4] otr: what happens when over the rice is here?\n",
    " 1 file changed, 1 insertion(+), 1 deletion(-)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "now, I `push`...\n",
    "\n",
    "**EXCEPT**\n",
    "\n",
    "remember, the `git push` command has two arguments it expects:\n",
    "\n",
    "```sh\n",
    "git push [remote] [branch (technically, a refspec)]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "previously we have either been explicit in writing\n",
    "\n",
    "```sh\n",
    "git push origin master\n",
    "```\n",
    "\n",
    "or we have left off the `origin master` arguments entirely because the default `remote` and `branch` (`refspec`) values are set when the branch is created."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "when the `master` branch was created, the `remote` defaults to `origin`, and the default `branch` value is `master` (I *told* you `master` was a `branch`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*this time*\n",
    "\n",
    "+ we are still publishing our results to the same place (`github`), so our `remote` is still the alias `origin` which points to `github`\n",
    "+ the `branch` we are pushing to is new and called `otr`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "# note the \"origin otr\" instead of \"origin master\"\n",
    "git push origin otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Counting objects: 3, done.\n",
    "Compressing objects: 100% (2/2), done.\n",
    "Writing objects: 100% (3/3), 354 bytes | 354.00 KiB/s, done.\n",
    "Total 3 (delta 0), reused 0 (delta 0)\n",
    "remote: \n",
    "remote: Create a pull request for 'otr' on GitHub by visiting:\n",
    "remote:      https://github.com/RZachLamberty/tacoworld/pull/new/otr\n",
    "remote: \n",
    "To github.com:RZachLamberty/tacoworld.git\n",
    " * [new branch]      otr -> otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "meanwhile, back [on `github`](https://github.com/RZachLamberty/tacoworld):\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1DXzG-XC6zJ_R73OJind8Tk8syVM10kF_\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "locally, what has happened is perhaps easiest to see in the log:\n",
    "\n",
    "```sh\n",
    "git log --oneline --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "37a75a4 (HEAD -> otr, origin/otr) otr: what happens when over the rice is here?\n",
    "dad7986 (origin/master, master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "+ our `HEAD` (current working state) is synced up with the branch we have checked out, `otr`\n",
    "+ `otr` and `origin/otr` are synced up because we have pushed our local changes to `origin`\n",
    "+ the `otr` branch is one `commit` ahead of the `master` branch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### diverging code paths\n",
    "\n",
    "while I've been off preparing for OTR contingencies, Eamon has been trying to find a way to defuse the situation with his difficult ~coworker~ parent. he's decided to make a code change in the hope of resolving some of the tension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "at this point, the workflow is old hat:\n",
    "\n",
    "+ `pull` to get up to date\n",
    "+ check the `log` to see what changed\n",
    "+ edit\n",
    "+ `add` to stage changes\n",
    "+ `commit` to commit them to record\n",
    "+ `push` to share them with the world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**what happens when Eamon `git pull`s??**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "it depends! what is the exact command he uses?\n",
    "\n",
    "```sh\n",
    "git pull\n",
    "git pull origin master\n",
    "git pull origin otr\n",
    "git pull --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Eamon isn't interested in OTR at this point so he just does the basic thing\n",
    "\n",
    "```sh\n",
    "# he has master checked out locally, so this\n",
    "# command implies `origin master` as its arguments\n",
    "git pull\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "remote: Enumerating objects: 8, done.\n",
    "remote: Counting objects: 100% (8/8), done.\n",
    "remote: Compressing objects: 100% (4/4), done.\n",
    "remote: Total 6 (delta 0), reused 6 (delta 0), pack-reused 0\n",
    "Unpacking objects: 100% (6/6), done.\n",
    "From github.com:RZachLamberty/tacoworld\n",
    "   1d12ddf..dad7986  master     -> origin/master\n",
    " * [new branch]      otr        -> origin/otr\n",
    "Updating 1d12ddf..dad7986\n",
    "Fast-forward\n",
    " tacoworld.py | 2 +-\n",
    " 1 file changed, 1 insertion(+), 1 deletion(-)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git log --oneline\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "dad7986 (HEAD -> master, origin/master, origin/HEAD) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "yikes... what a baby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Eamon updates the `tacoworld.py` file to read\n",
    "\n",
    "```python\n",
    "print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    "print(\"I, Eamon Lamberty, want tacos, so it's good there are enough to share!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git add -p\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "diff --git a/tacoworld.py b/tacoworld.py\n",
    "index e79a838..2205480 100644\n",
    "--- a/tacoworld.py\n",
    "+++ b/tacoworld.py\n",
    "@@ -1,2 +1,2 @@\n",
    " print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    "-print(\"I, Eamon Lamberty, want tacos!!\")\n",
    "+print(\"I, Eamon Lamberty, want tacos, so it's good there are enough to share!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git commit -m 'tacoworld: plenty o tacos'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "[master b68db37] tacoworld: plenty o tacos\n",
    " 1 file changed, 1 insertion(+), 1 deletion(-)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "# note: origin master is implied here again!\n",
    "git push\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Counting objects: 3, done.\n",
    "Compressing objects: 100% (2/2), done.\n",
    "Writing objects: 100% (3/3), 316 bytes | 316.00 KiB/s, done.\n",
    "Total 3 (delta 1), reused 0 (delta 0)\n",
    "remote: Resolving deltas: 100% (1/1), completed with 1 local object.\n",
    "To github.com:RZachLamberty/tacoworld.git\n",
    "   dad7986..b68db37  master -> master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "and just like that\n",
    "\n",
    "we have\n",
    "\n",
    "a fork\n",
    "\n",
    "<div align=\"center\"><img src=\"https://image.freepik.com/free-icon/code-fork-symbol_318-55528.jpg\" width=400></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `git fetch`, `git merge`, and \"local remote\" `branch`es\n",
    "\n",
    "okay, let's seriously level up our `git` knowledge.\n",
    "\n",
    "I mentioned up above that a `git pull` was really a combination of two steps:\n",
    "\n",
    "+ a \"remote\" command `git fetch`\n",
    "+ a \"local\" command `git merge`\n",
    "\n",
    "let's dig into that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I (not Eamon) pull up the `log` again:\n",
    "\n",
    "```sh\n",
    "git log --oneline --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "37a75a4 (HEAD -> otr, origin/otr) otr: what happens when over the rice is here?\n",
    "dad7986 (origin/master, master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "whenever we've actually explicitly typed out commands involving the phrases `origin`, `master`, and `otr`, there has been a space between them:\n",
    "\n",
    "```sh\n",
    "git pull origin master\n",
    "git push origin otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "but those tags have a **slash**:\n",
    "\n",
    "```\n",
    "origin/master\n",
    "origin/otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "what if I told you that those tags were actually *local* `branch`es tracking *remote* `branch`es, and you were really syncing up with `origin/master` instead of `origin master` this whole time\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://gif-finder.com/wp-content/uploads/2015/12/Tim-Eric-Mind-Blown.gif\" width=\"480\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "let's break this down.\n",
    "\n",
    "although `git` *could* constantly be checking on `origin` (e.g. `github`) for changes, it *isn't*.\n",
    "\n",
    "it only checks for changes when you tell it to, and the way it does that is with a command called `git fetch`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`git fetch` does the following:\n",
    "\n",
    "+ sends a message out over the internet to the `remote` (`github`) asking if anything changed\n",
    "+ `github` responds with a \"no\" or with new `commit`s\n",
    "+ takes new `commit`s and updates a *LOCAL* branch that is *VERY SPECIAL*, and designed to be completely locked to the state of the `remote` (`github`)\n",
    "    + unlike local branches you create, you can't make edits to this special branch\n",
    "    + the name is, by default, `[origin name]/[branch or refspec name]`, so we have two such branches now: `origin/master` and `origin/otr`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we have two local branches we are editing (`master` and `otr`) and two special local branches which are tracking `remote`s (conveniently called \"remote branches\" because that's the most confusing thing to call them)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "we can update both of the tracking branches with\n",
    "\n",
    "```sh\n",
    "git fetch --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Fetching origin\n",
    "remote: Enumerating objects: 5, done.\n",
    "remote: Counting objects: 100% (5/5), done.\n",
    "remote: Compressing objects: 100% (1/1), done.\n",
    "remote: Total 3 (delta 1), reused 3 (delta 1), pack-reused 0\n",
    "Unpacking objects: 100% (3/3), done.\n",
    "From github.com:RZachLamberty/tacoworld\n",
    "   dad7986..b68db37  master     -> origin/master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I recorded the output of `git log --oneline --all` before and after that command:\n",
    "\n",
    "```\n",
    "37a75a4 (HEAD -> otr, origin/otr) otr: what happens when over the rice is here?\n",
    "dad7986 (origin/master, master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```\n",
    "\n",
    "and after\n",
    "\n",
    "```\n",
    "b68db37 (origin/master) tacoworld: plenty o tacos\n",
    "37a75a4 (HEAD -> otr, origin/otr) otr: what happens when over the rice is here?\n",
    "dad7986 (master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "the `fetch` command was informed by `github` of the only thing that Eamon changed on remote -- the `master` branch -- and as a result it updated the *local remote branch* `origin/master`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**<div align=\"center\">you with me so far? PAUSE FOR ZOOM BREAK</div>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "now like I said, `git pull` is a combo of `git fetch` and `git merge`. what is `git merge`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### `git merge`\n",
    "\n",
    "every `branch` has a most recent `commit`\n",
    "\n",
    "```\n",
    "b68db37 (origin/master) tacoworld: plenty o tacos\n",
    "37a75a4 (HEAD -> otr, origin/otr) otr: what happens when over the rice is here?\n",
    "dad7986 (master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "1d12ddf tacoworld: goo goo ga ga\n",
    "6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "0041239 tacoworld: initial commit\n",
    "```\n",
    "\n",
    "+ `origin/master` points to `b68db37`\n",
    "+ `otr` and `origin/otr` point to `37a75a4`\n",
    "+ `master` points to `dad7986`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`git merge` is a command which will take your current active state (the most recent commit of your current branch) and try and apply the `commit` history of another point in the `git` commit graph (that is, all the changes made to get to that file state) on top of your current active state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "the `ascii` diagrams in the `git merge --help` manual are useful here:\n",
    "\n",
    "if we have `master` checked out and run `git merge topic`, that will make the following schematic updates (read from left to right):\n",
    "\n",
    "```\n",
    "      A---B---C topic\n",
    "     /\n",
    "D---E---F---G master\n",
    "```\n",
    "\n",
    "becomes\n",
    "\n",
    "```\n",
    "      A---B---C topic\n",
    "     /         \\\n",
    "D---E---F---G---H master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "note that this is the most general case and results in two different paths \"merging\" (hence the name).\n",
    "\n",
    "a very common case is one in which one branch (e.g. `origin/master`) sits *directly* ahead of another (e.g. `master`). this is called a \"fast forward\" merge."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "let's check out `master` and look at the log, this time with `--graph` to make beautiful `ascii` art\n",
    "\n",
    "```sh\n",
    "git checkout master\n",
    "git log --oneline --graph --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "# helpful hint from `git` that we're behind, first:\n",
    "Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.\n",
    "  (use \"git pull\" to update your local branch)\n",
    "\n",
    "# and then\n",
    "\n",
    "* b68db37 (origin/master) tacoworld: plenty o tacos\n",
    "| * 37a75a4 (origin/otr, otr) otr: what happens when over the rice is here?\n",
    "|/  \n",
    "* dad7986 (HEAD -> master) tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "* 1d12ddf tacoworld: goo goo ga ga\n",
    "* 6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "* 0041239 tacoworld: initial commit\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "our current state (`HEAD -> master`) has two paths it could go forward (sync up with `origin/master`, the remote branch, or move toward the `otr` branch.\n",
    "\n",
    "the changes that Eamon made to the remote were implemented in our local remote branch `origin/master`. let's also incorporate those changes in our local `master` branch as well by using `git merge`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git merge origin/master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Updating dad7986..b68db37\n",
    "Fast-forward\n",
    " tacoworld.py | 2 +-\n",
    " 1 file changed, 1 insertion(+), 1 deletion(-)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git log --oneline --graph --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "* b68db37 (HEAD -> master, origin/master) tacoworld: plenty o tacos\n",
    "| * 37a75a4 (origin/otr, otr) otr: what happens when over the rice is here?\n",
    "|/  \n",
    "* dad7986 tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "* 1d12ddf tacoworld: goo goo ga ga\n",
    "* 6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "* 0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ...why did I just do that?\n",
    "\n",
    "okay, so, in practice you may just end up typing `git pull` all the time and letting `git` try and do the `fetch` (will always work!) and the `merge` (will only work if a fast forward merge is possible). usually, that's good enough.\n",
    "\n",
    "**when `git pull` fails**, though, it will fail in the `merge` step. at that time, it's good to know what changed for you (your remote tracking branches) and what `git` is trying to do in that moment (`merge`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "also, sometimes you will have made local changes and you won't be sure if remote changes have been made yet. you can *always* run `git fetch` with *no* side effects, so if all you want to do is find out what the outside world is up to, run `git fetch` instead of `git pull`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### one last `merge`\n",
    "\n",
    "today's the day. I've had tacos for 100 days in a row (my model is extremely consistent, what can I say) and I see OTR outside.\n",
    "\n",
    "I decide to deploy my OTR `branch` into production. I want to `merge` it into `master`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "take a second to think about this: I want to take the changes I made in the `otr` branch and incorporate them into the `master` branch.\n",
    "\n",
    "**<div align=\"center\">what should I do?</div>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git checkout master\n",
    "git merge otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "Auto-merging tacoworld.py\n",
    "CONFLICT (content): Merge conflict in tacoworld.py\n",
    "Automatic merge failed; fix conflicts and then commit the result.\n",
    "```\n",
    "\n",
    "<br><div align=\"center\"><img src=\"https://media1.tenor.com/images/0a37ef8f52e2232d85a2070d56801987/tenor.gif?itemid=5026106\" width=500></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### resolving conflicts\n",
    "\n",
    "finally, at some point you will just have conflicts. at least with `git` you will know where they are.\n",
    "\n",
    "`git` tried its very best to apply the changes I made in the `otr` branch on top of the current state of `master`, but it couldn't be done -- one of the lines in `master` (Eamon's line) has changed since I started `otr`. I have to resolve the conflict."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`git` lets us *know* that there is a conflict by editing the `tacoworld.py` file and adding markers to show us the \"before and after\" of our different code versions. the general format is\n",
    "\n",
    "```\n",
    "unchanged code...\n",
    "unchanged code...\n",
    "<<<<<<< HEAD\n",
    "the version of the code\n",
    "that is in the current\n",
    "working state (i.e. HEAD)\n",
    "=======\n",
    "the version of the code\n",
    "that is in the new branch\n",
    "change state (i.e. otr)\n",
    ">>>>>>> [the name of the branch or sha we are merging into HEAD]\n",
    "more unchanged code...\n",
    "more unchanged code...\n",
    "...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "in this particular instance, the conflict is the entire file:\n",
    "\n",
    "```\n",
    "<<<<<<< HEAD\n",
    "print(\"I, Zach Lamberty, want tacos more than *anyone*, especially more than Eamon!\")\n",
    "print(\"I, Eamon Lamberty, want tacos, so it's good there are enough to share!\")\n",
    "=======\n",
    "print(\"Today, actually, I (Zach Lamberty), want OTR!\")\n",
    "print(\"I, Eamon Lamberty, want tacos!!\")\n",
    ">>>>>>> otr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "+ the first block is the current state of `master`\n",
    "    + we want to take the 2nd line (Eamon's edited line) from this block\n",
    "+ the second block is the current state of `otr`\n",
    "    + we want to take the 1st line (my edited line) from this block\n",
    "\n",
    "crack open a text editor and actually make those edits. when you're confident you've done it correctly, remove the `<<<<<<<`, `=======`, and `>>>>>>>` lines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "the end result is:\n",
    "\n",
    "```python\n",
    "print(\"Today, actually, I (Zach Lamberty), want OTR!\")\n",
    "print(\"I, Eamon Lamberty, want tacos, so it's good there are enough to share!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "normally after adding changes we would run `git add -p`. however, while resolving conflicts there is not `patch`ing to do -- just add the entire file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```sh\n",
    "git add tacoworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "then, create a commit indicating that this was a `merge` commit which incorporated the `otr` branch:\n",
    "\n",
    "```sh\n",
    "git commit -m 'merging otr branch changes'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "[master e030810] merging otr branch changes\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "look at what we did!\n",
    "\n",
    "```sh\n",
    "git log --oneline --graph --all\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "*   e030810 (HEAD -> master) merging otr branch changes\n",
    "|\\  \n",
    "| * 37a75a4 (origin/otr, otr) otr: what happens when over the rice is here?\n",
    "* | b68db37 (origin/master) tacoworld: plenty o tacos\n",
    "|/  \n",
    "* dad7986 tacoworld: v cool good for you eamon but I wanted tacos first bubs so back off\n",
    "* 1d12ddf tacoworld: goo goo ga ga\n",
    "* 6e98be1 tacoworld: my name is Zach and I do not fear my hunger\n",
    "* 0041239 tacoworld: initial commit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "go ahead and `push` that out to the world\n",
    "\n",
    "```sh\n",
    "git push origin master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "Counting objects: 3, done.\n",
    "Compressing objects: 100% (2/2), done.\n",
    "Writing objects: 100% (3/3), 402 bytes | 402.00 KiB/s, done.\n",
    "Total 3 (delta 0), reused 0 (delta 0)\n",
    "To github.com:RZachLamberty/tacoworld.git\n",
    "   b68db37..e030810  master -> master\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## a second approach to collaboration: pull requests and forking\n",
    "\n",
    "I mentioned wayyyyyyy back at the start of this lecture `github` allows you to add collaborators to your repo as one way of working together. I also suggested there was another -- that other way is very common and very cool."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`github` (not `git`, mind you!) supports a second type of workflow:\n",
    "\n",
    "+ I own a main repo (in this case, `tacoworld`) and share it on `github`\n",
    "+ you create a branch based off of my `github` master branch\n",
    "    + this can happen in two ways!\n",
    "        + you are a collaborator and do it the same way we showed above\n",
    "        + you `fork` that repo -- create an independent copy of the repository that you control completely\n",
    "\n",
    "<br><div align=\"center\"><img src=\"http://drive.google.com/uc?export=view&id=1Lcv_LF2VFHk5eZlBGtZzp_iWNtIkX7Q-\" width=\"850\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "+ you get your branch on your local machine (`clone` my repo that has your branch, or `clone` your `fork`ed copy)\n",
    "+ you make your changes\n",
    "+ you `push` them back up to `github`\n",
    "+ `github` (not `git`!) can compare your `branch` to `master`\n",
    "    + for single-repo situations it's obvious; for `fork` copies `github` is comparing changes you make to my original repo\n",
    "+ `github` presents a button asking if you would like to create a `pull request`\n",
    "+ this initiates an entirely-web-based and entirely-`github`-based process of asking me to approve the changes you made\n",
    "    + companies put a lot of process here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "I won't dive into this now because we will cover it in depth on a future homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## last resorts\n",
    "\n",
    "[warning: language is NSFW, but it's assumed this is a resource when language is already being maximally deployed](https://ohshitgit.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## follow-up resources\n",
    "\n",
    "+ http://try.github.io/ *especially the \"learn by doing\"* sections!\n",
    "+ rtfm: https://git-scm.com/doc\n",
    "+ a short primer on `git merge`: https://dev.to/neshaz/how-to-use-git-merge-the-correctway-25pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div align=\"center\"><code>git</code> along, little doggies</div>\n",
    "<div align=\"center\"><img align=\"middle\" src=\"https://i.ytimg.com/vi/9cSpDCYo1GM/maxresdefault.jpg\" width=600></div>\n",
    "\n",
    "# END OF LECTURE\n",
    "\n",
    "\n",
    "next lecture: [`python`](005_python.ipynb)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}