git-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Intro to Git and GitHub\n",
    "\n",
    "### Humna Awan\n",
    "#### Society of Physics Students, Rutgers University\n",
    "#### April 16, 2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Git: the tool you didn't know you needed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Git\n",
    "A version control software"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## GitHub\n",
    "Cloud based service for version control via Git."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Sources of this material:\n",
    "This tutorial is adapted from a tutorial presented by Jake Vanderplas in the [LSST Data Science Fellowship Program](https://github.com/LSSTC-DSFP/LSSTC-DSFP-Sessions/tree/master/Session1 )."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lets cover some basics before dealing with Git and GitHub directly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is Version Control?\n",
    "\n",
    "We all implement it, e.g.,\n",
    "* paper_draft_v1.pdf\n",
    "* paper_draft_v2.pdf\n",
    "* paper_draft_v2a.pdf\n",
    "* paper_draft_v2a_1.pdf\n",
    "...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "and we all know the perils of that kind of file-handling."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is Version Control?\n",
    "\n",
    "#### From Wikipedia:\n",
    "“Revision control, also known as version control, source control\n",
    "or software configuration management (SCM), is the\n",
    "**management of changes to documents, programs, and other information stored as computer files.**”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Reproducibility?\n",
    "\n",
    "* Tracking and recreating every step of your work\n",
    "* In the software world: it's called *Version Control*!\n",
    "\n",
    "What do (good) version control tools give you?\n",
    "\n",
    "* Peace of mind (backups)\n",
    "* Freedom (exploratory branching)\n",
    "* Collaboration (synchronization)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Git is an enabling technology: use version control for everything\n",
    "* Code management\n",
    "* Custom style files and macros\n",
    "* Collaborative writing (group projects, proposals)\n",
    "* Everyday research\n",
    "* Personal website history tracking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The plan for this tutorial\n",
    "\n",
    "- Overview of Git key concepts\n",
    "\n",
    "- Hands-on work with Git, primarily with a use of GitHub as a remote"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Git usage\n",
    "\n",
    "- 5 \"stages\" of using Git:\n",
    "            \n",
    "    1. Local, single-user, linear workflow\n",
    "    2. Single local user, branching\n",
    "    3. Using remotes as a single user\n",
    "    4. Remotes for collaborating in a small team\n",
    "    5. Full-contact github: distributed collaboration with large teams\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## My advice\n",
    "\n",
    "- Use GitHub as a remote, _always_ (unless you want to set up your own remote). \n",
    "    - Allows you to develop as you choose your workflow (linear or with branching)\n",
    "    - Allows for small and large collaborations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## High level picture: overview of key concepts\n",
    "\n",
    "The **commit**: *a snapshot of work at a point in time*\n",
    "\n",
    "![](files/images/commit_anatomy.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Credit: ProGit book, by Scott Chacon, CC License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## High level picture: overview of key concepts\n",
    "\n",
    "A **repository**: a group of *linked* commits\n",
    "\n",
    "![](files/images/threecommits.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Note: these form a Directed Acyclic Graph (DAG), with nodes identified by their *hash*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## High level picture: overview of key concepts\n",
    "\n",
    "A **hash**: a fingerprint of the content of each commit *and its parent*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import hashlib\n",
    "\n",
    "# Our first commit\n",
    "data1 = 'This is the start of my paper.'\n",
    "meta1 = 'date: 1/1/12'\n",
    "commit1 = '%s%s'%(data1, meta1)\n",
    "hash1 = hashlib.sha1(commit1.encode('utf-8')).hexdigest()\n",
    "\n",
    "print('Hash:', hash1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Our second commit, linked to the first\n",
    "data2 = 'Added content my paper ...'\n",
    "meta2 = 'date: 1/2/12'\n",
    "# Note we add the parent hash here!\n",
    "commit2 = '%s%s%s'%(data1, meta2, hash1)\n",
    "hash2 = hashlib.sha1(commit2.encode('utf-8')).hexdigest()\n",
    "\n",
    "print('Hash:', hash2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And this is pretty much the essence of Git!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lets Get To It\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Lets first get you a version of this notebook\n",
    "- Please go [my GitHub repository containing this tutorial](https://github.com/humnaawan/git-tutorial )\n",
    "- Click on the `clone or download` button.\n",
    "- Click on `Download as zip` button.\n",
    "- Open the ipython notebook in the folder you just downloaded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Git and GitHub: Access\n",
    "\n",
    "Lets make sure that we have the necessary tools at hand:\n",
    "\n",
    "* [Install git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git ) on your laptop if you don't already have it.\n",
    "    - If you don't know if you have git, run `git --version` in your terminal. If it runs, then you're good to go.\n",
    "    \n",
    "    \n",
    "* [Sign up for a GitHub account](https://github.com/ ) if you don't already have it.\n",
    "    - You might want  to use your `.edu` email, as then you can get student access to unlimited repositories (more soon)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Git and GitHub: Access\n",
    "\n",
    "* [Set up SSH connection to your GitHub account](https://help.github.com/en/articles/connecting-to-github-with-ssh )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "First check if you have a publich SSH (when running this in your terminal, run without the ! at the beginning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!ls -al ~/.ssh | grep .pub"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- If you dont have a public SSH key, please [generate one and add it to the ssh agent](https://help.github.com/en/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Then, [add the SSH key to your GitHub account](https://help.github.com/en/articles/adding-a-new-ssh-key-to-your-github-account )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Configuring Git\n",
    "\n",
    "The minimal amount of configuration for git to work without pestering you is to tell it who you are.  All the commands here modify the ``.gitconfig`` file in your home\n",
    "directory.\n",
    "\n",
    "Lets first check the contents of the config file (again, when running this in your terminal, run without the ! at the beginning):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!cat ~/.gitconfig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If the `.gitconfig` file doesn't have your info, please modify it (again, when running these in your terminal, run without the ! at the beginning):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "# you'll need to comment the next two lines out if you're running in this ipython notebook\n",
    "#git config --global user.name \"John Doe\"\n",
    "#git config --global user.email \"johndoe@uw.edu\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Check the config file again to be sure (again, without the ! at the beginning if running in your terminal):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!cat ~/.gitconfig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Github offers in its help pages instructions on how to configure the credentials helper for [Mac OSX](https://help.github.com/articles/set-up-git#platform-mac) and [Windows](https://help.github.com/articles/set-up-git#platform-windows)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stage 1: Local, single-user, linear workflow\n",
    "Simply type `git` to see a full list of all the 'core' commands.  We'll now go through most of these via small practical exercises:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git init`: create an empty repository"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "rm -rf test\n",
    "git init test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Note:** if you're running the upcoming cells in the terminal, you need to cd into the `test` folder only once.\n",
    "\n",
    "Since we are putting all of them here in a single notebook for the purposes of the tutorial, they will all be prepended with the first two lines:\n",
    "\n",
    "    %%bash\n",
    "    cd test\n",
    "\n",
    "that tell iPython to do that each time.  But you should ignore those two lines and type the rest of each cell yourself in your terminal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's look at what git did:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls -la"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls -l .git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Now let's create our first file in the test directory with a text editor ... here, we are doing it programatically, but you'd normally be editing by hand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "echo \"My first bit of text\" > file1.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls -al"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git status`: see what git notices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git add`: tell git about our new file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git add file1.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets check the `status` again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git commit`:  record our changes in git's database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git commit -m \"This is our first commit\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In the commit above, we  used the `-m` flag to specify a message at the command line.\n",
    "\n",
    "If we don't do that, git will open the editor we specified in our configuration above and require that we enter a message.\n",
    "\n",
    "By default, git refuses to record changes that don't have a message to go along with them (though you can obviously 'cheat' by using an empty or meaningless string: git only tries to facilitate best practices, it's not your nanny)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets check the `status` again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git log`: what has been committed so far"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git diff`: what have I changed?\n",
    "Let's do a little bit more work. Again, in practice you'll be editing the files by hand, here we do it via shell commands for the sake of automation (and therefore the reproducibility of this tutorial!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "echo \"And now some more text...\" >> file1.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And now we can ask git what is different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets check the `status` again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The cycle of git virtue: work, add, commit, work,  add, commit, ...\n",
    "\n",
    "- Work\n",
    "- Check status (and diff for more details)\n",
    "- Add file(s)\n",
    "- Commit staged file(s)\n",
    "- Repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git add 'file1.txt'\n",
    "git commit -m \"I have made great progress on this critical matter.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git log` revisited\n",
    "First, let's see what the log shows us now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Sometimes it's handy to see a very summarized version of the log:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git log --oneline --topo-order --graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Defining an alias\n",
    "\n",
    "Git supports *aliases:* new names given to command combinations. Let's make this handy shortlog an alias, so we only have to type `git slog` and see this compact log:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "# We create our alias (this saves it in git's permanent configuration file):\n",
    "git config --global alias.slog \"log --oneline --topo-order --graph\"\n",
    "\n",
    "# And now we can use it\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git mv` and `rm`: moving and removing files\n",
    "While `git add` is used to add fils to the list git tracks, we must also tell it if we want their  names to change or for it to stop tracking them.  In familiar Unix fashion, the `mv` and `rm` git commands do precisely this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git mv file1.txt file-newname.txt\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note that these changes must be committed too, to become permanent!  In git's world, until something hasn't been committed, it isn't permanently recorded anywhere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git add 'file-newname.txt'\n",
    "git commit -m \"I like this new name better\"\n",
    "echo \"Let's look at the log again:\"\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And `git rm` works in a similar fashion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise\n",
    "Add a new file `file2.txt`, add and commit it, make some changes to it, add and commit them again, and then remove it (and don't forget to add/commit this last step!)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2. Single Local user, branching\n",
    "What is a branch?  Simply a *label for the 'current' commit in a sequence of ongoing commits*:\n",
    "\n",
    "![](files/images/masterbranch.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Mulitple Branches\n",
    "There can be multiple branches alive at any point in time; the working directory is the state of a special pointer called HEAD.  In this example there are two branches, *master* and *testing*, and *testing* is the currently active branch since it's what HEAD points to:\n",
    "\n",
    "![](files/images/HEAD_testing.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Once new commits are made on a branch, HEAD and the branch label move with the new commits:\n",
    "\n",
    "![](files/images/branchcommit.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This allows the history of both branches to diverge:\n",
    "\n",
    "![](files/images/mergescenario.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "But based on this graph structure, git can compute the necessary information to merge the divergent branches back and continue with a unified line of development:\n",
    "    \n",
    "![](files/images/mergeaftermath.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Branching Example\n",
    "\n",
    "Let's now illustrate all of this with a concrete example.  Let's get our bearings first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We are now going to try two different routes of development: on the `master` branch we will add one file and on the `experiment` branch, which we will create, we will add a different one.  We will then merge the experimental branch into `master`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets first see what branch(es) exist already"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git branch --list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The * points out the branch you're on"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Lets create a new branch and see what changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git branch experiment\n",
    "git checkout experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Notice how we are no longer on the `master` branch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can also check the branch list again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git branch --list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Lets now add content while we are on the `experiment` branch; add and commit it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "# add file\n",
    "echo \"Some crazy idea\" > experiment.txt\n",
    "\n",
    "# add and committ\n",
    "git add 'experiment.txt'\n",
    "git commit -m \"Trying something new\"\n",
    "\n",
    "# lets see the log\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets see what files exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Lets now go back to `master`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git checkout master\n",
    "\n",
    "# lets see the log\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "and add to it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "# new file\n",
    "echo \"All the while, more work goes on in master...\" >> file-newname.txt\n",
    "\n",
    "# add and commit\n",
    "git add 'file-newname.txt'\n",
    "git commit -m \"The mainline keeps moving\"\n",
    "\n",
    "# check the log\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets see what files exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Lets `merge` the two branches now so that all the work is in `master`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git merge experiment\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Once you're done with a branch, you can delete it (e.g. by running `git branch -d <branch-name>`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3. Using remotes as a single user"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lets now connect our local repository to a *remote repository*: a pointer to another copy of the repository that lives on a different location (e.g. on GitHub)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ``git remote``: view/modify remote repositories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "ls\n",
    "echo \"Let's see if we have any remote repositories here:\"\n",
    "git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Since the above cell didn't produce any output after the `git remote -v` call, it means we have no remote repositories configured."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Configuring a remote\n",
    "Go to the [new repository page](https://github.com/new) and make a repository called `test` (stick with the default of a Public repository).\n",
    "\n",
    "Do **not** check the box that says `Initialize this repository with a README`, since we already have an existing repository locally.  That option is useful when you're starting first at Github and don't have a repo made already on a local computer.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can now follow the instructions mentioned in the repo page, and add the remote to our local repo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git remote add origin git@github.com:humnaawan/test.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's see the remote situation again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Pushing changes to a remote repository\n",
    "\n",
    "Now push the ``master`` branch to the remote named ``origin``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git push origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can now [see this repository publicly on github](https://github.com/humnaawan/test)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Using Git to Sync Work\n",
    "\n",
    "Let's see how this can be useful for backup and syncing work between two different computers.  I'll simulate a 2nd computer by working in a different directory..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "# here I clone my 'test' repo but with a different name, test2, to simulate a 2nd computer\n",
    "git clone https://github.com/humnaawan/test.git test2\n",
    "cd test2\n",
    "pwd\n",
    "git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's now make some changes in one 'computer' and synchronize them on the second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test2  # working on computer #2\n",
    "\n",
    "echo \"More new content on my experiment\" >> experiment.txt\n",
    "git add 'experiment.txt'\n",
    "git commit -m \"More work, on machine #2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Now we put this new work up on the github server so it's available from the internet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test2\n",
    "\n",
    "git push origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Now let's fetch that work from machine #1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git pull origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## An important aside: conflict management\n",
    "While git is very good at merging, if two different branches modify the same file in the same location, it simply can't decide which change should prevail.  At that point, human intervention is necessary to make the decision.  Git will help you by marking the location in the file that has a problem, but it's up to you to resolve the conflict.  Let's see how that works by intentionally creating a conflict.\n",
    "\n",
    "We start by creating a branch and making a change to our experiment file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "# create a new branch\n",
    "git branch trouble\n",
    "git checkout trouble\n",
    "\n",
    "# create a file\n",
    "echo \"This is going to be a problem...\" >> experiment.txt\n",
    "\n",
    "# add and commit\n",
    "git add 'experiment.txt'\n",
    "git commit -m \"Changes in the trouble branch\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And now we go back to the master branch, where we change the *same* file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git checkout master\n",
    "\n",
    "echo \"More work on the master branch...\" >> experiment.txt\n",
    "\n",
    "git add 'experiment.txt'\n",
    "git commit -m \"Mainline work\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The conflict...\n",
    "\n",
    "So now let's see what happens if we try to merge the `trouble` branch into `master`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git merge trouble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Let's see what git has put into our file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "cat experiment.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "At this point, we go into the file with a text editor, decide which changes to keep, and make a new commit that records our decision.  I've now made the edits, in this case I decided that both pieces of text were useful, but integrated them with some changes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "cat experiment.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's then make our new commit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd test\n",
    "\n",
    "git add 'experiment.txt'\n",
    "git commit -m \"Completed merge of trouble, fixing conflicts along the way\"\n",
    "\n",
    "# lets check the log now\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Merge Tools\n",
    "\n",
    "*Note:* While it's a good idea to understand the basics of fixing merge conflicts by hand, in some cases you may find the use of an automated tool useful.\n",
    "\n",
    "Git supports multiple [merge tools](https://www.kernel.org/pub/software/scm/git/docs/git-mergetool.html): a merge tool is a piece of software that conforms to a basic interface and knows how to merge two files into a new one.  Since these are typically graphical tools, there are various to choose from for the different operating systems, and as long as they obey a basic command structure, git can work with any of them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4. Collaborating on github with a small team\n",
    "\n",
    "Here we will set up a shared collaboration with one partner -- choose someone sitting next to you.  We will have two people, let's call them P1 and P2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1. Synchronization\n",
    "\n",
    "We begin with a simple synchronization example.  Working together, follow these steps:\n",
    "\n",
    "#### Creating a new repository\n",
    "- P1: create a new repository on github called ``p1-test``\n",
    "- P1: create a file ``README.md`` in your `p1-test` repository, add/commit it, and push it to the remote.\n",
    "- P1: on github, go to the settings for ``p1-test``, and add your partner (P2) to the list of collaborators\n",
    "\n",
    "#### Cloning your partner's repository\n",
    "- P2: clone the P1s ``p1-test`` repository using ``git clone [url]``\n",
    "- P2: makes changes to the ``README.md`` file and add/commit locally.\n",
    "- P2: push changes to github.\n",
    "- P1: pull P1's changes to the local repository.\n",
    "\n",
    "Now P1 and P2 should both have the same ``README.md`` file on their own computer. Repeat with the roles swapped."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2. Dealing with conflicts\n",
    "\n",
    "Next, we will have both parties make non-conflicting changes each, and commit them locally.  Then both try to push their changes:\n",
    "\n",
    "- P1: create & add/commit a new file, ``p1.txt`` to the local repo\n",
    "- P2: create & add/commit a new file, ``p2.txt`` to the local repo\n",
    "- P1: push the latest commit to github\n",
    "- P2: try to push to github.  What happens?\n",
    "\n",
    "The problem is that P2's changes create a commit that conflicts with P1's, so git refuses to apply them.\n",
    "\n",
    "P2 must do\n",
    "\n",
    "`git pull origin master`\n",
    "    \n",
    "And then deal with the conflict manually, then push again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 5. Full-contact github: distributed collaboration with large teams\n",
    "\n",
    "On large teams, you don't always want all contributors to have access to the main repository.  So how do you move forward?  Using Pull Requests.\n",
    "\n",
    "Again, we'll do this as an exercise with your partner:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We'll practice this here, by having P1 now *fork* P2's repository.\n",
    "\n",
    "2. **P1:** go to P2's github page for the `p2-test` repo,  and click the *fork* button.  You now have your own remote version of the repository, that looks like ``http://github.com/P1/p2-test.git``\n",
    "\n",
    "3. **P1:** use ``git clone [url]`` to get a local version of *your fork* on your own computer. \n",
    "\n",
    "4. **P1:** use ``git remote add upstream [url]`` to add a pointer to P2's remote (the original)\n",
    "\n",
    "5. **P1:** type ``git remote -v``, and you should see both your own fork (called ``origin``) and P2's fork (called ``upstream``)\n",
    "\n",
    "6. **P1:** create a new branch called ``p1_changes``\n",
    "\n",
    "7. **P1:** add a file called ``p1.txt``, add/commit, and use ``git push origin p1_changes`` to push to the remote.\n",
    "\n",
    "8. **P1:** reload the github page for *your own* fork: there should now be a button that says \"compare and pull request\".  Click it and fill it out.\n",
    "\n",
    "9. **P2:** go to your own notifications page (the blue circle in the upper-left of GitHub) and you should see a notification of P1's Pull request.  Check the diff, add some comments, and merge the changes.\n",
    "\n",
    "10. **P1:** on your computer, checkout the master branch, and update it from P2's fork with ``git pull upstream master``\n",
    "\n",
    "Congratulations!  You're now a collaborator!\n",
    "\n",
    "This is how virtually all open source collaboration proceeds on Github!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Further resources\n",
    "\n",
    "- See Jake Vanderplas's [tutorial notebook](https://github.com/jakevdp/git-intro/blob/master/git-intro.ipynb ) for additional material/references; I've adapted the notebook for this tutorial.\n",
    "- Phil Marshall's [gettingStarted repo](https://github.com/drphilmarshall/GettingStarted ); there are very helpful Q/A + a video tutorial of some of the basics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}