Git Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Torvalds' Divine Comedy: paths through the midway of your Git journey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Note:** The starting point for this tutorial was\n",
    "\n",
    "- [Version control for fun and profit](http://nbviewer.jupyter.org/github/fperez/reprosw/blob/master/Version%20Control.ipynb) by [Fernando Perez](http://fperez.org/), which in turn was particularly modeled on, and therefore owes a lot to, the materials in:\n",
    "\n",
    "- [\"Git for Scientists: A Tutorial\"](http://nyuccl.org/pages/GitTutorial) by John McDonnell \n",
    "- Emanuele Olivetti's lecture notes and exercises from the G-Node summer school on [Advanced Scientific Programming in Python](https://python.g-node.org/wiki/schedule).\n",
    "\n",
    "In particular it re-reuses the excellent images from the [Pro Git book](http://git-scm.com/book) that John had already selected and downloaded, as well as some of his outline.  But Fernando's version of the tutorial aimed to be 100% reproducible by being executed directly as an IPython notebook.  Many thanks to Fernando, John, and Emanuele for making their materials available online.\n",
    "\n",
    "This Brandeis fork of Fernando's interactive tutorial, however, is aimed at computer science-savvy people who know the basics of Git, but don't always feel that they know why they're repeating these incantations in the order they're repeating them, or what exactly is going through Git's little state machine when it barfs error messages. This tutorial also assumes little knowledge of unix concepts, and makes a point of mentioning little unix tips as asides.\n",
    "\n",
    "The key divergence from Fernando's basis is some excruciating detail on the front end, and then the creation of additional common-and/or-scary situations with guidance to resolve them.\n",
    "\n",
    "We also use the `bash` kernel for Jupyter, rather than explicitly shelling out at every step as was necessary in Fernando's notebook. Install it from https://github.com/takluyver/bash_kernel, or you can try running this cell (I haven't tried this without the bash kernel installed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "pip install bash_kernel\n",
    "python -m bash_kernel.install"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## The plan for this tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This tutorial is structured in the following way: we will begin with a detailed account of how git keeps track of what happens when you `add`, `commit`, `merge`, etc.  We will then dive into hands-on work: after a brief interlude into necessary configuration we will discuss 5 \"stages of git\" with scenarios of increasing sophistication and complexity, introducing the necessary commands for each stage:\n",
    "            \n",
    "1. What happens when you `init`, `add`, and `commit`.\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. Ways things can go wrong\n",
    "    \n",
    "In reality, this tutorial only covers stages 1-5, since for #6 there are many software develoment-oriented tutorials and documents of very high quality online.  But most scientists start working alone with a few files or with a small team, so I feel it's important to build first the key concepts and practices based on problems scientists encounter in their everyday life and without the jargon of the software world.  Once you've become familiar with 1-4, the excellent tutorials that exist about collaborating on github on open-source projects should make sense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Very high level picture: an overview of key concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Have you seen a picture like this before?\n",
    "\n",
    "![](git-transport.png)\n",
    "\n",
    "The leftmost part, **workspace**, is actually just another name for \"the files on your computer's filesystem\" under git's (partial) control. You and git share control of the files within a repository, except that git doesn't even think about the existence of files that you haven't told it about (with `git add`).\n",
    "\n",
    "One thing that I feel is underemphasized: **workspace is the least important part of this flow** from git's perspective. The state of your files is a separate concern from everything else that the repo deals with. One thing you should know, in order to feel safe in git, is that once you commit a state of the tracked files in your workspace, you can do whatever you want to the files in workspace. As long as you don't mess up the `.git/` directory, you can always get back to where you were when you committed. I think that's the reason why it is grey in the diagram above, and also why the `git diff` commmands are grey.\n",
    "\n",
    "What's in the `.git/` directory, then? Let's create a new one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## First things first: git must be configured before first use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The minimal amount of configuration for git to work without pestering you is to tell it who you are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git config --global user.name \"EDIT THIS AND WRITE YOUR FULL NAME HERE\"\n",
    "git config --global user.email \"your@email.com\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    " And how you will edit text files (it will often ask you to edit messages and other information, and thus wants to know how you like to edit your files):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Put here your preferred editor. If this is not set, git will honor\n",
    "# the $EDITOR environment variable\n",
    "# git config --global core.editor /usr/local/bin/vim  # \n",
    "\n",
    "# On Windows Notepad will do in a pinch, I recommend Notepad++ as a free alternative\n",
    "# On the mac, you can set nano or emacs as a basic option\n",
    "\n",
    "# And while we're at it, we also turn on the use of color, which is very useful\n",
    "git config --global color.ui \"auto\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Set git to use the credential memory cache so we don't have to retype passwords too frequently. On Linux, you should run the following (note that this requires git version 1.7.10 or newer):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git config --global credential.helper cache\n",
    "# Set the cache to timeout after 2 hours (setting is in seconds)\n",
    "git config --global credential.helper 'cache --timeout=7200'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "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": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git init`: create an empty repository"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized empty Git repository in /Users/orion/Google Drive/2017Spring/Seminar/test/.git/\n"
     ]
    }
   ],
   "source": [
    "rm -rf test\n",
    "\n",
    "git init test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cd test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Note:** all these cells below are meant to be run from the `test` directory. If you change directories in a cell that you create, subsequent git calls may do something funny; to fix it, `cd` back to the `test` directory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# What's In An Empty Repo?\n",
    "\n",
    "Let's look at the aftermath of `git init`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ls -l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "(There is no output). That's just because the file is hidden by having its name start with a period; you can show hidden files by adding the `-a` flag to `ls`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x   3 orion  staff  102 Mar 10 11:21 \u001b[34m.\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x@ 14 orion  staff  476 Mar 10 11:21 \u001b[34m..\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   9 orion  staff  306 Mar 10 11:21 \u001b[34m.git\u001b[39;49m\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "ls -la"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The `-R` flag lists a directory's contents recursively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 24\n",
      "-rw-r--r--   1 orion  staff   23 Mar 10 11:21 HEAD\n",
      "-rw-r--r--   1 orion  staff  137 Mar 10 11:21 config\n",
      "-rw-r--r--   1 orion  staff   73 Mar 10 11:21 description\n",
      "drwxr-xr-x  12 orion  staff  408 Mar 10 11:21 \u001b[34mhooks\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   3 orion  staff  102 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:21 \u001b[34mobjects\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:21 \u001b[34mrefs\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/hooks:\n",
      "total 88\n",
      "-rwxr-xr-x  1 orion  staff   478 Mar 10 11:21 \u001b[31mapplypatch-msg.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff   896 Mar 10 11:21 \u001b[31mcommit-msg.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff   189 Mar 10 11:21 \u001b[31mpost-update.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff   424 Mar 10 11:21 \u001b[31mpre-applypatch.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff  1642 Mar 10 11:21 \u001b[31mpre-commit.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff  1348 Mar 10 11:21 \u001b[31mpre-push.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff  4951 Mar 10 11:21 \u001b[31mpre-rebase.sample\u001b[39;49m\u001b[0m\n",
      "-rw-r--r--  1 orion  staff   544 Mar 10 11:21 pre-receive.sample\n",
      "-rwxr-xr-x  1 orion  staff  1239 Mar 10 11:21 \u001b[31mprepare-commit-msg.sample\u001b[39;49m\u001b[0m\n",
      "-rwxr-xr-x  1 orion  staff  3610 Mar 10 11:21 \u001b[31mupdate.sample\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/info:\n",
      "total 8\n",
      "-rw-r--r--  1 orion  staff  240 Mar 10 11:21 exclude\n",
      "\n",
      ".git/objects:\n",
      "total 0\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n",
      "\n",
      ".git/refs:\n",
      "total 0\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34mheads\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34mtags\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/refs/heads:\n",
      "\n",
      ".git/refs/tags:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We're going to be looking closely at `.git/objects` for a little while, so let's reiterate how boring and empty it is now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Now you start adding files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 8\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:22 \u001b[34m.\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x@ 14 orion  staff  476 Mar 10 11:21 \u001b[34m..\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   9 orion  staff  306 Mar 10 11:21 \u001b[34m.git\u001b[39;49m\u001b[0m\n",
      "-rw-r--r--   1 orion  staff   21 Mar 10 11:22 file1.txt\n"
     ]
    }
   ],
   "source": [
    "echo \"My first bit of text\" > file1.txt\n",
    "ls -la"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff  68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "Initial commit\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31mfile1.txt\u001b[m\n",
      "\n",
      "nothing added to commit but untracked files present (use \"git add\" to track)\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So, the first principle, even if it is very hard to trust and internalize: **git doesn't know or care about files you haven't told it about**. It can, however, list files that it is not tracking."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `git add`: tell git about this new file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 24\n",
      "-rw-r--r--   1 orion  staff   23 Mar 10 11:21 HEAD\n",
      "-rw-r--r--   1 orion  staff  137 Mar 10 11:21 config\n",
      "-rw-r--r--   1 orion  staff   73 Mar 10 11:21 description\n",
      "drwxr-xr-x  12 orion  staff  408 Mar 10 11:21 \u001b[34mhooks\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   3 orion  staff  102 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:21 \u001b[34mobjects\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:21 \u001b[34mrefs\u001b[39;49m\u001b[0m\n",
      "On branch master\n",
      "\n",
      "Initial commit\n",
      "\n",
      "Changes to be committed:\n",
      "  (use \"git rm --cached <file>...\" to unstage)\n",
      "\n",
      "\t\u001b[32mnew file:   file1.txt\u001b[m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ls -l .git\n",
    "git add file1.txt # typically no output\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "What happened internally to make this happen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:22 \u001b[34mce\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/ce:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  37 Mar 10 11:22 645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Notice** that there is a new plain file here, `index`. It contains binary data, which if you really want, you can inspect with `hexdump`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00000000  44 49 52 43 00 00 00 02  00 00 00 01 58 c2 d2 b4  |DIRC........X...|\n",
      "00000010  00 00 00 00 58 c2 d2 b4  00 00 00 00 01 00 00 06  |....X...........|\n",
      "00000020  03 1f 74 5a 00 00 81 a4  00 00 01 f6 00 00 00 14  |..tZ............|\n",
      "00000030  00 00 00 15 ce 64 5c 7a  c0 24 e8 f0 ae 22 e0 d6  |.....d\\z.$...\"..|\n",
      "00000040  c3 c2 d5 98 7e 5a 22 23  00 09 66 69 6c 65 31 2e  |....~Z\"#..file1.|\n",
      "00000050  74 78 74 00 18 d8 a9 fa  0e a8 b3 da 16 0b e6 c7  |txt.............|\n",
      "00000060  42 96 c9 1a 52 a5 50 76                           |B...R.Pv|\n",
      "00000068\n"
     ]
    }
   ],
   "source": [
    "hexdump -C .git/index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "But the real way to look at it is to use `git ls-files`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223 0\tfile1.txt\n"
     ]
    }
   ],
   "source": [
    "git ls-files --stage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice that the file is stored inside `.git/objects/ce/645c7ac...` where the first two characters of the full hash is the directory name, and the other 38 characters are the filename. (Note, also, that the hexdump output, starting on the fourth line, contains this hash as well — expressed more efficiently, since the values `ce 64 5c...` etc. are all single bytes, instead of being the one byte each as they are in UTF-8:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "echo ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223 | hexdump -C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "But I digress. The important thing is this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ls .git/objects/ce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice, more importantly, that I am writing this on a Sunday afternoon, but I know that a file with the contents \"My first bit of text\" will end up in directory `ce/` in file named `645c7ac...`.\n",
    "\n",
    "### ☞ Why this partitioning scheme, and what does it remind you of? ☜"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Why: efficiency of filesystem access.\n",
    "- What: a **hash**: i.e. the output of a hashing function. In Git, this a fingerprint of the content of each commit *and its parent*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223  -\n"
     ]
    }
   ],
   "source": [
    "echo -ne \"blob 21\\0My first bit of text\\n\" | shasum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Unix protip**: you can get the length of a Bash string variable `$foo` by doing `${#foo}` . For more human-unreadable tricks like this see http://tldp.org/LDP/abs/html/string-manipulation.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "data=\"My first bit of text\n",
    "\"\n",
    "echo -ne \"blob ${#data}\\0$data\" | shasum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "data1='This is the start of my paper2.'\n",
    "hash1=`echo -ne \"blob ${#data1}\\0$data1\" | shasum`\n",
    "echo $hash1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Our second commit, linked to the first\n",
    "data2='Some more text in my paper...'\n",
    "meta2='date: 1/21/2020'\n",
    "# Note we add the parent hash here!\n",
    "hash2=`echo -ne $data2 $meta2 $hash1 | shasum`\n",
    "echo $hash2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And this is pretty much the essence of Git!\n",
    "\n",
    "Bare files in `objects` are hashed purely on their content; trees and commits, which we'll see below, are also hashed with their date, so in some of the cells below I will know the hash, but in others I'll have to pull it dynamically."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git commit`: permanently record our changes in git's database"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We added a file to the index, and Git knows about it now. But looking at this diagram again:\n",
    "\n",
    "![](git-transport.png)\n",
    "\n",
    "We're only one step past the `workspace`. We're in the \"index\", but not in the \"local repository\". Git knows the file, but hasn't made a record for it in the history of the repo. You know how to see the history of a repo, right?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fatal: your current branch 'master' does not have any commits yet\n"
     ]
    },
    {
     "ename": "",
     "evalue": "128",
     "output_type": "error",
     "traceback": []
    }
   ],
   "source": [
    "git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In general, as you may know by now, you can call `git commit` with a few different options:\n",
    "\n",
    "- (no options) - commit files that have been staged in the index with `git add` \n",
    "- `-a` - automatically stage already-tracked files that have been modified or deleted; ignore anything new\n",
    "- `<file...>` list, by name, specific files you want to commit (in addition to staged ones).\n",
    " \n",
    "Since we've just staged our new file and we don't have any others, we don't have to use any flags — except for one to specify the commit message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master (root-commit) 0a4a9f0] This is our first commit\n",
      " 1 file changed, 1 insertion(+)\n",
      " create mode 100644 file1.txt\n"
     ]
    }
   ],
   "source": [
    "git commit -m \"This is our first commit\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In the commit above, we  used the `-m` flag to specify a message at the command line.  If we don't do that, git will open the editor we specified in our configuration above and require that we enter a message.  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).\n",
    "\n",
    "But what else has happened? First line, beginning `[master (root-commit) BLABLAH]` has a real value in BLABLAH, and I can't guess what it is as I write this, because it is computed based on the moment the commit was made."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# TO `HEAD`!\n",
    "\n",
    "I really wanted to tell you about `HEAD` later, but since the flow of this tutorial sort of depends on it, we're going to have to start addressing it now. We had a file with hash that was predictable because that hash was based solely on the content of the file. Then we committed, and ended up with a hash that is not predictable because the hashed value includes the date that the commit was done. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 40\n",
      "-rw-r--r--   1 orion  staff   25 Mar 10 11:25 COMMIT_EDITMSG\n",
      "-rw-r--r--   1 orion  staff   23 Mar 10 11:21 HEAD\n",
      "-rw-r--r--   1 orion  staff  137 Mar 10 11:21 config\n",
      "-rw-r--r--   1 orion  staff   73 Mar 10 11:21 description\n",
      "drwxr-xr-x  12 orion  staff  408 Mar 10 11:21 \u001b[34mhooks\u001b[39;49m\u001b[0m\n",
      "-rw-r--r--   1 orion  staff  137 Mar 10 11:25 index\n",
      "drwxr-xr-x   3 orion  staff  102 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:25 \u001b[34mlogs\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   7 orion  staff  238 Mar 10 11:25 \u001b[34mobjects\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x   4 orion  staff  136 Mar 10 11:21 \u001b[34mrefs\u001b[39;49m\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "ls -l .git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ref: refs/heads/master\n"
     ]
    }
   ],
   "source": [
    "cat .git/HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0a4a9f0eef158724ce97874950942bb3586d0935\n"
     ]
    }
   ],
   "source": [
    "cat .git/refs/heads/master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### We could put that in a shell variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0a4a9f0eef158724ce97874950942bb3586d0935\n"
     ]
    }
   ],
   "source": [
    "last_commit=`cat .git/refs/heads/master`\n",
    "echo $last_commit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "but in practice that is just the default argument to a bunch of git commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### What objects do we have in `.git/objects`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34m0a\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34ma7\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:22 \u001b[34mce\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/0a:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  139 Mar 10 11:25 4a9f0eef158724ce97874950942bb3586d0935\n",
      "\n",
      ".git/objects/a7:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  54 Mar 10 11:25 3ca0c3b54f0b93abf0157f398864b0daf556fd\n",
      "\n",
      ".git/objects/ce:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  37 Mar 10 11:22 645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We had one thing in `.git/objects` before, and now we have three. We recognize one of them as the `file1.txt` that we've examined; we recognize another one from the commit hash we just got. But there's a third one, too. These are binary files, like the `index` we hexdumped, so there's no point looking at them directly, but we can ask git to show us what's in their binary format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 blob ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\tfile1.txt\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p a73ca0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And that's the source of our third file: this `tree` hash."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Ok, what are we looking at?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Suppose you needed to implement version control yourself.\n",
    "\n",
    "The **commit**: *a snapshot of work at a point in time*\n",
    "\n",
    "<!-- offline: \n",
    "![](fig/commit_anatomy.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/commit_anatomy.png\">\n",
    "\n",
    "Credit: ProGit book, by Scott Chacon, CC License."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree a73ca0c3b54f0b93abf0157f398864b0daf556fd\n",
      "author Orion Montoya <orion@mdcclv.com> 1489163148 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489163148 -0500\n",
      "\n",
      "This is our first commit\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p $last_commit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 blob ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\tfile1.txt\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p a73ca0c3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223 0\tfile1.txt\n"
     ]
    }
   ],
   "source": [
    "git ls-files --stage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## By the way -- blobs don't care what their filename is, only what their contents are.\n",
    "\n",
    "Let's make a new file with the same content as the one before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master a6caae9] Copy that file for demo\n",
      " 1 file changed, 1 insertion(+)\n",
      " create mode 100644 file1a.txt\n"
     ]
    }
   ],
   "source": [
    "echo \"My first bit of text\" > file1a.txt\n",
    "git add file1a.txt\n",
    "git commit -m \"Copy that file for demo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree 45fa2d70498e73771b0cb31a1d92c99d7047dbe8\n",
      "parent 0a4a9f0eef158724ce97874950942bb3586d0935\n",
      "author Orion Montoya <orion@mdcclv.com> 1489163384 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489163384 -0500\n",
      "\n",
      "Copy that file for demo\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p HEAD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## ☞ This `tree` object also has a predictable hash, because it is the hash of the following contents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 blob ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\tfile1.txt\n",
      "100644 blob ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\tfile1a.txt\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p 45fa2d7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### `git diff`: what have I changed?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "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!)\n",
    "\n",
    "Before, we created a file with content by echoing to \"> filename\". That makes an empty file and adds text to it. Two arrows will do that, too, but if the file already exists it will append to the end of it instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "echo \"And now some more text...\" >> file1.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And now we can ask git what is different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/file1.txt b/file1.txt\u001b[m\n",
      "\u001b[1mindex ce645c7..4baa979 100644\u001b[m\n",
      "\u001b[1m--- a/file1.txt\u001b[m\n",
      "\u001b[1m+++ b/file1.txt\u001b[m\n",
      "\u001b[36m@@ -1 +1,2 @@\u001b[m\n",
      " My first bit of text\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mAnd now some more text...\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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",
      "\t\u001b[31mmodified:   file1.txt\u001b[m\n",
      "\n",
      "no changes added to commit (use \"git add\" and/or \"git commit -a\")\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34m0a\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34m45\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34ma6\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34ma7\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:22 \u001b[34mce\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/0a:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  139 Mar 10 11:25 4a9f0eef158724ce97874950942bb3586d0935\n",
      "\n",
      ".git/objects/45:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  59 Mar 10 11:29 fa2d70498e73771b0cb31a1d92c99d7047dbe8\n",
      "\n",
      ".git/objects/a6:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  168 Mar 10 11:29 caae9499295f25ddfdf0919f23612aae742e03\n",
      "\n",
      ".git/objects/a7:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  54 Mar 10 11:25 3ca0c3b54f0b93abf0157f398864b0daf556fd\n",
      "\n",
      ".git/objects/ce:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  37 Mar 10 11:29 645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We changed a file, and git can describe what changed, but it hasn't made any changes to the `.git/objects` directory yet because we haven't staged anything — we just have local changes in our workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "Changes to be committed:\n",
      "  (use \"git reset HEAD <file>...\" to unstage)\n",
      "\n",
      "\t\u001b[32mmodified:   file1.txt\u001b[m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "git add file1.txt\n",
    "git status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34m0a\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34m45\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:31 \u001b[34m4b\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34ma6\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34ma7\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:22 \u001b[34mce\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/0a:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  139 Mar 10 11:25 4a9f0eef158724ce97874950942bb3586d0935\n",
      "\n",
      ".git/objects/45:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  59 Mar 10 11:29 fa2d70498e73771b0cb31a1d92c99d7047dbe8\n",
      "\n",
      ".git/objects/4b:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  60 Mar 10 11:31 aa979a0af89c9d52506593c7b5390c84a05b70\n",
      "\n",
      ".git/objects/a6:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  168 Mar 10 11:29 caae9499295f25ddfdf0919f23612aae742e03\n",
      "\n",
      ".git/objects/a7:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  54 Mar 10 11:25 3ca0c3b54f0b93abf0157f398864b0daf556fd\n",
      "\n",
      ".git/objects/ce:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  37 Mar 10 11:29 645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unstaged changes after reset:\n",
      "M\tfile1.txt\n"
     ]
    }
   ],
   "source": [
    "git reset HEAD file1.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The file has been unstaged, but FWIW the updated blob of it in 4baa979 still exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree 45fa2d70498e73771b0cb31a1d92c99d7047dbe8\n",
      "parent 0a4a9f0eef158724ce97874950942bb3586d0935\n",
      "author Orion Montoya <orion@mdcclv.com> 1489163384 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489163384 -0500\n",
      "\n",
      "Copy that file for demo\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p HEAD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Before, the header of HEAD was three lines: `tree, author, committer` (and then the commit message). Now it is four: there is an extra line saying what is the `parent` of this commit. Every commit after the first will have this. Back to the implementation diagrams:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A **repository**: a group of *linked* commits\n",
    "\n",
    "<!-- offline: \n",
    "![](files/fig/threecommits.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/threecommits.png\" >\n",
    "\n",
    "Note: these form a Directed Acyclic Graph (DAG), with nodes identified by their *hash*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `git log`: what has been committed so far"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mcommit a6caae9499295f25ddfdf0919f23612aae742e03\u001b[m\n",
      "Author: Orion Montoya <orion@mdcclv.com>\n",
      "Date:   Fri Mar 10 11:29:44 2017 -0500\n",
      "\n",
      "    Copy that file for demo\n",
      "\n",
      "\u001b[33mcommit 0a4a9f0eef158724ce97874950942bb3586d0935\u001b[m\n",
      "Author: Orion Montoya <orion@mdcclv.com>\n",
      "Date:   Fri Mar 10 11:25:48 2017 -0500\n",
      "\n",
      "    This is our first commit\n"
     ]
    }
   ],
   "source": [
    "git log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34m0a\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34m45\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:31 \u001b[34m4b\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34ma6\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34ma7\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:22 \u001b[34mce\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/0a:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  139 Mar 10 11:25 4a9f0eef158724ce97874950942bb3586d0935\n",
      "\n",
      ".git/objects/45:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  59 Mar 10 11:29 fa2d70498e73771b0cb31a1d92c99d7047dbe8\n",
      "\n",
      ".git/objects/4b:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  60 Mar 10 11:31 aa979a0af89c9d52506593c7b5390c84a05b70\n",
      "\n",
      ".git/objects/a6:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  168 Mar 10 11:29 caae9499295f25ddfdf0919f23612aae742e03\n",
      "\n",
      ".git/objects/a7:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  54 Mar 10 11:25 3ca0c3b54f0b93abf0157f398864b0daf556fd\n",
      "\n",
      ".git/objects/ce:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  37 Mar 10 11:29 645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### The cycle of git virtue: work, commit, work, commit, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master cd49e05] I have made great progress on this critical matter.\n",
      " 1 file changed, 1 insertion(+)\n"
     ]
    }
   ],
   "source": [
    "git commit -a -m\"I have made great progress on this critical matter.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 0\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34m0a\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34m45\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:31 \u001b[34m4b\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:29 \u001b[34ma6\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:25 \u001b[34ma7\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:33 \u001b[34mcd\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:22 \u001b[34mce\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  3 orion  staff  102 Mar 10 11:33 \u001b[34me1\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34minfo\u001b[39;49m\u001b[0m\n",
      "drwxr-xr-x  2 orion  staff   68 Mar 10 11:21 \u001b[34mpack\u001b[39;49m\u001b[0m\n",
      "\n",
      ".git/objects/0a:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  139 Mar 10 11:25 4a9f0eef158724ce97874950942bb3586d0935\n",
      "\n",
      ".git/objects/45:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  59 Mar 10 11:29 fa2d70498e73771b0cb31a1d92c99d7047dbe8\n",
      "\n",
      ".git/objects/4b:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  60 Mar 10 11:33 aa979a0af89c9d52506593c7b5390c84a05b70\n",
      "\n",
      ".git/objects/a6:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  168 Mar 10 11:29 caae9499295f25ddfdf0919f23612aae742e03\n",
      "\n",
      ".git/objects/a7:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  54 Mar 10 11:25 3ca0c3b54f0b93abf0157f398864b0daf556fd\n",
      "\n",
      ".git/objects/cd:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  185 Mar 10 11:33 49e05ed32b7d1e9ef685fab5f0807959486e9c\n",
      "\n",
      ".git/objects/ce:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  37 Mar 10 11:29 645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\n",
      "\n",
      ".git/objects/e1:\n",
      "total 8\n",
      "-r--r--r--  1 orion  staff  80 Mar 10 11:33 4d35d9509833a16b7814f518c5fe7c04d8fca5\n",
      "\n",
      ".git/objects/info:\n",
      "\n",
      ".git/objects/pack:\n"
     ]
    }
   ],
   "source": [
    "ls -lR .git/objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cd49e05ed32b7d1e9ef685fab5f0807959486e9c\n"
     ]
    }
   ],
   "source": [
    "cat .git/refs/heads/master"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree e14d35d9509833a16b7814f518c5fe7c04d8fca5\n",
      "parent a6caae9499295f25ddfdf0919f23612aae742e03\n",
      "author Orion Montoya <orion@mdcclv.com> 1489163630 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489163630 -0500\n",
      "\n",
      "I have made great progress on this critical matter.\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p `cat .git/refs/heads/master`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 blob 4baa979a0af89c9d52506593c7b5390c84a05b70\tfile1.txt\n",
      "100644 blob ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\tfile1a.txt\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p `git cat-file -p HEAD | head -1 | awk '{print $2}'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first bit of text\n",
      "And now some more text...\n"
     ]
    }
   ],
   "source": [
    "# this bit never has to change because the content is the same!\n",
    "git cat-file -p 4baa979"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### what will we see when we add another file?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master baf007f] refactoring\n",
      " 1 file changed, 1 insertion(+)\n",
      " create mode 100644 file2.txt\n"
     ]
    }
   ],
   "source": [
    "echo \"breaking things into sub-components\" >> file2.txt\n",
    "git add file2.txt\n",
    "git commit -m \"refactoring\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree 5e2831d9384ee8f43bde45bd04909f190902bc57\n",
      "parent cd49e05ed32b7d1e9ef685fab5f0807959486e9c\n",
      "author Orion Montoya <orion@mdcclv.com> 1489163725 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489163725 -0500\n",
      "\n",
      "refactoring\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100644 blob 4baa979a0af89c9d52506593c7b5390c84a05b70\tfile1.txt\n",
      "100644 blob ce645c7ac024e8f0ae22e0d6c3c2d5987e5a2223\tfile1a.txt\n",
      "100644 blob 2ed01a294f59cd2cda1fd438be46f5939bc7a69c\tfile2.txt\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p 5e2831d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So again, as we see here:\n",
    "\n",
    "<!-- offline: \n",
    "![](fig/commit_anatomy.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/commit_anatomy.png\">\n",
    "\n",
    "a commit points to a tree, a tree points to a list of blobs, and blobs are files with particular contents. This is a directed acyclic graph if there ever was one. A branch is just the root of a particular chain of commits.\n",
    "\n",
    "When you check out a branch, looks at the tree for it, looks at the blobs in it, and just dumps the contents of those blobs into files inside your workspace directory. Every revision of every file exists inside `.git/objects`; git just puts each thing in its proper place for you when you ask it.\n",
    "\n",
    "But how, then, do you move from one branch to another? There must be a list of heads of trees somewhere, right? Enter the `.git/refs/`.\n",
    "\n",
    "You know how, with breadth-first search, it doesn't really matter which node you start on? With a connected graph, any node *could* be the root. HEAD is just a reference to a node that is the root of the tree you want to have checked out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ref: refs/heads/master\n"
     ]
    }
   ],
   "source": [
    "cat .git/HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "baf007facc76f5e237236854f65fe169d684d25b\n"
     ]
    }
   ],
   "source": [
    "cat .git/refs/heads/master"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Switched to a new branch 'test2.0'\n"
     ]
    }
   ],
   "source": [
    "git checkout -b test2.0\n",
    "#git checkout test2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 16\n",
      "-rw-r--r--  1 orion  staff  41 Mar 10 11:35 master\n",
      "-rw-r--r--  1 orion  staff  41 Mar 10 11:36 test2.0\n"
     ]
    }
   ],
   "source": [
    "ls -l .git/refs/heads/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "baf007facc76f5e237236854f65fe169d684d25b\n",
      "baf007facc76f5e237236854f65fe169d684d25b\n"
     ]
    }
   ],
   "source": [
    "cat .git/refs/heads/*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Right now these two heads are identical. But let's make another commit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[test2.0 2f91016] big-picture vision stuff\n",
      " 1 file changed, 1 insertion(+)\n",
      " create mode 100644 file3.txt\n"
     ]
    }
   ],
   "source": [
    "echo \"TODO: decide between imperial and metric unit tests\" >> file3.txt\n",
    "echo \"notes that I don't want to track\" >> notes.txt\n",
    "git add file3.txt\n",
    "git commit -am \"big-picture vision stuff\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "master  test2.0\n"
     ]
    }
   ],
   "source": [
    "ls .git/refs/heads/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "baf007facc76f5e237236854f65fe169d684d25b\n",
      "2f91016ce3cef3b81629e479d4e9e008d3ce88da\n"
     ]
    }
   ],
   "source": [
    "cat .git/refs/heads/*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 40\n",
      "-rw-r--r--  1 orion  staff  47 Mar 10 11:31 file1.txt\n",
      "-rw-r--r--  1 orion  staff  21 Mar 10 11:29 file1a.txt\n",
      "-rw-r--r--  1 orion  staff  36 Mar 10 11:35 file2.txt\n",
      "-rw-r--r--  1 orion  staff  52 Mar 10 11:37 file3.txt\n",
      "-rw-r--r--  1 orion  staff  33 Mar 10 11:37 notes.txt\n"
     ]
    }
   ],
   "source": [
    "ls -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Switched to branch 'master'\n",
      "total 32\n",
      "-rw-r--r--  1 orion  staff  47 Mar 10 11:31 file1.txt\n",
      "-rw-r--r--  1 orion  staff  21 Mar 10 11:29 file1a.txt\n",
      "-rw-r--r--  1 orion  staff  36 Mar 10 11:35 file2.txt\n",
      "-rw-r--r--  1 orion  staff  33 Mar 10 11:37 notes.txt\n"
     ]
    }
   ],
   "source": [
    "git checkout master\n",
    "ls -l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice that:\n",
    "1. **file3.txt disappeared**. It is tracked in the `test2.0` branch, but it does not exist in `master`, so git cleans it up.\n",
    "2. **`notes.txt` is still there**. It is not tracked in any branch, so git doesn't try to do anything to it at all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master ec30798] executive decisions\n",
      " 1 file changed, 1 insertion(+)\n",
      " create mode 100644 file3.txt\n"
     ]
    }
   ],
   "source": [
    "echo \"Boss says let's go with imperial unit tests\" >> file3.txt\n",
    "git add file3.txt\n",
    "git commit -am \"executive decisions\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "gitk --all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## The meta-point\n",
    "\n",
    "The meta-point here is that, now that you've had Data Structures and stuff, every piece of software was written by an idiot just like you, with recourse to the same data structures and algorithms as you. Understanding how a system fits together can help you master it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## now to merge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \u001b[32mmaster\u001b[m\n",
      "  test2.0\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git branch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Auto-merging file3.txt\n",
      "CONFLICT (add/add): Merge conflict in file3.txt\n",
      "Automatic merge failed; fix conflicts and then commit the result.\n"
     ]
    },
    {
     "ename": "",
     "evalue": "1",
     "output_type": "error",
     "traceback": []
    }
   ],
   "source": [
    "git merge test2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merging:\n",
      "file3.txt\n",
      "\n",
      "Normal merge conflict for 'file3.txt':\n",
      "  {local}: created file\n",
      "  {remote}: created file\n",
      "2017-03-10 11:41:54.396 FileMerge[4282:9975607] Unable to load platform at path /Applications/Xcode.app/Contents/Developer/Platforms/AppleTVOS.platform\n",
      "2017-03-10 11:41:54.398 FileMerge[4282:9975607] Unable to load platform at path /Applications/Xcode.app/Contents/Developer/Platforms/AppleTVSimulator.platform\n",
      "2017-03-10 11:41:54.399 FileMerge[4282:9975607] Unable to load platform at path /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform\n",
      "2017-03-10 11:41:54.400 FileMerge[4282:9975607] Unable to load platform at path /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform\n",
      "2017-03-10 11:41:54.405 FileMerge[4282:9975607] Unable to load platform at path /Applications/Xcode.app/Contents/Developer/Platforms/WatchOS.platform\n",
      "2017-03-10 11:41:54.406 FileMerge[4282:9975607] Unable to load platform at path /Applications/Xcode.app/Contents/Developer/Platforms/WatchSimulator.platform\n",
      "2017-03-10 11:41:54.412 FileMerge[4282:9975607] Couldn't load '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/Library/Xcode/Specifications/Core Build System.xcspec'. Reason: Error Domain=NSCocoaErrorDomain Code=3840 \"Unexpected character b at line 1\" UserInfo={NSDebugDescription=Unexpected character b at line 1, kCFPropertyListOldStyleParsingError=Error Domain=NSCocoaErrorDomain Code=3840 \"Unexpected ';' or '=' after key at line 1\" UserInfo={NSDebugDescription=Unexpected ';' or '=' after key at line 1}}.\n",
      "2017-03-10 11:41:54.418 FileMerge[4282:9975607] Couldn't load '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/Library/Xcode/Specifications/Native Build System.xcspec'. Reason: Error Domain=NSCocoaErrorDomain Code=3840 \"Unexpected character b at line 1\" UserInfo={NSDebugDescription=Unexpected character b at line 1, kCFPropertyListOldStyleParsingError=Error Domain=NSCocoaErrorDomain Code=3840 \"Unexpected ';' or '=' after key at line 1\" UserInfo={NSDebugDescription=Unexpected ';' or '=' after key at line 1}}.\n"
     ]
    }
   ],
   "source": [
    "git mergetool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "All conflicts fixed but you are still merging.\n",
      "  (use \"git commit\" to conclude merge)\n",
      "\n",
      "Changes to be committed:\n",
      "\n",
      "\t\u001b[32mmodified:   file3.txt\u001b[m\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31mfile3.txt.orig\u001b[m\n",
      "\t\u001b[31mnotes.txt\u001b[m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master e63b0b9] resolved organizational conflict\n"
     ]
    }
   ],
   "source": [
    "git commit -m \"resolved organizational conflict\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Cherrypick\n",
    "\n",
    "Actually, at this point I think I can describe `git cherry-pick` to you and you can tell me how it is implemented.\n",
    "\n",
    "You're in a branch, and you have some commits. You want to pull in changes from another commit or list of commits. You're in the branch you want the changes in. You call `git cherry-pick <commits>`. Now the changes are part of your branch history.\n",
    "\n",
    "- are the commit hashes the same, or different?\n",
    "\n",
    "## Reflog\n",
    "\n",
    "Ok. Remember how your current branch is recorded in `.git/HEAD`, and that points to a place like `refs/heads/master` or `refs/heads/<branchname>`? Well, it turns out git keeps a log of what your HEAD is pointing to every time it changes, and you can look at it.\n",
    "\n",
    "This is great in various situations where you messed up history. Maybe you did a reset to rollback some commits, but realized you had some good work in the second-to-last commit. Maybe you inadvertently rebased `master` and then inadvertently force-pushed, and the clock is ticking for everyone to get mad at you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33me63b0b9\u001b[m HEAD@{0}: commit (merge): resolved organizational conflict\n",
      "\u001b[33mec30798\u001b[m HEAD@{1}: commit: executive decisions\n",
      "\u001b[33mbaf007f\u001b[m HEAD@{2}: checkout: moving from test2.0 to master\n",
      "\u001b[33m2f91016\u001b[m HEAD@{3}: commit: big-picture vision stuff\n",
      "\u001b[33mbaf007f\u001b[m HEAD@{4}: checkout: moving from master to test2.0\n",
      "\u001b[33mbaf007f\u001b[m HEAD@{5}: commit: refactoring\n",
      "\u001b[33mcd49e05\u001b[m HEAD@{6}: commit: I have made great progress on this critical matter.\n",
      "\u001b[33ma6caae9\u001b[m HEAD@{7}: commit: Copy that file for demo\n",
      "\u001b[33m0a4a9f0\u001b[m HEAD@{8}: commit (initial): This is our first commit\n"
     ]
    }
   ],
   "source": [
    "git reflog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Indexing from HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree ac98f0ffa6405a9d2be88530b128fa6efbdbd00d\n",
      "parent e63b0b965b0dd9dae8014c9cecec45cce0758414\n",
      "author Orion Montoya <orion@mdcclv.com> 1489165170 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489165194 -0500\n",
      "\n",
      "one thing and another\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree 8558234198eb9c2b5435e1e0c131bc8be802ab87\n",
      "parent ec30798af9980aa9b8016275d0e9264cf8a2999c\n",
      "parent 2f91016ce3cef3b81629e479d4e9e008d3ce88da\n",
      "author Orion Montoya <orion@mdcclv.com> 1489164230 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489164230 -0500\n",
      "\n",
      "resolved organizational conflict\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p HEAD~1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree e14d35d9509833a16b7814f518c5fe7c04d8fca5\n",
      "parent a6caae9499295f25ddfdf0919f23612aae742e03\n",
      "author Orion Montoya <orion@mdcclv.com> 1489163630 -0500\n",
      "committer Orion Montoya <orion@mdcclv.com> 1489163630 -0500\n",
      "\n",
      "I have made great progress on this critical matter.\n"
     ]
    }
   ],
   "source": [
    "git cat-file -p HEAD~4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/file3.txt b/file3.txt\u001b[m\n",
      "\u001b[1mnew file mode 100644\u001b[m\n",
      "\u001b[1mindex 0000000..b72e7d4\u001b[m\n",
      "\u001b[1m--- /dev/null\u001b[m\n",
      "\u001b[1m+++ b/file3.txt\u001b[m\n",
      "\u001b[36m@@ -0,0 +1 @@\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mbla bla\u001b[m\n",
      "\u001b[1mdiff --git a/file4.txt b/file4.txt\u001b[m\n",
      "\u001b[1mnew file mode 100644\u001b[m\n",
      "\u001b[1mindex 0000000..9797d05\u001b[m\n",
      "\u001b[1m--- /dev/null\u001b[m\n",
      "\u001b[1m+++ b/file4.txt\u001b[m\n",
      "\u001b[36m@@ -0,0 +1 @@\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mboo balbl\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff HEAD~3..HEAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/file3.txt b/file3.txt\u001b[m\n",
      "\u001b[1mindex b4345c3..b72e7d4 100644\u001b[m\n",
      "\u001b[1m--- a/file3.txt\u001b[m\n",
      "\u001b[1m+++ b/file3.txt\u001b[m\n",
      "\u001b[36m@@ -1,2 +1 @@\u001b[m\n",
      "\u001b[31m-Boss says let's go with imperial unit tests\u001b[m\n",
      "\u001b[31m-TODO: decide between imperial and metric unit tests\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mbla bla\u001b[m\n",
      "\u001b[1mdiff --git a/file4.txt b/file4.txt\u001b[m\n",
      "\u001b[1mnew file mode 100644\u001b[m\n",
      "\u001b[1mindex 0000000..9797d05\u001b[m\n",
      "\u001b[1m--- /dev/null\u001b[m\n",
      "\u001b[1m+++ b/file4.txt\u001b[m\n",
      "\u001b[36m@@ -0,0 +1 @@\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mboo balbl\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff master..test2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/file3.txt b/file3.txt\u001b[m\n",
      "\u001b[1mindex b72e7d4..b4345c3 100644\u001b[m\n",
      "\u001b[1m--- a/file3.txt\u001b[m\n",
      "\u001b[1m+++ b/file3.txt\u001b[m\n",
      "\u001b[36m@@ -1 +1,2 @@\u001b[m\n",
      "\u001b[31m-bla bla\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mBoss says let's go with imperial unit tests\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mTODO: decide between imperial and metric unit tests\u001b[m\n",
      "\u001b[1mdiff --git a/file4.txt b/file4.txt\u001b[m\n",
      "\u001b[1mdeleted file mode 100644\u001b[m\n",
      "\u001b[1mindex 9797d05..0000000\u001b[m\n",
      "\u001b[1m--- a/file4.txt\u001b[m\n",
      "\u001b[1m+++ /dev/null\u001b[m\n",
      "\u001b[36m@@ -1 +0,0 @@\u001b[m\n",
      "\u001b[31m-boo balbl\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff test2.0..master file*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Squashing commits/interactive rebase\n",
    "\n",
    "**This will happen to you.** I can't tell you how many workplace pissing contests have centered around a new person who doesn't squash their commits. Large, professional projects tend to want commits to be thematically isolated, and almost everybody wants their `master` history free of commits with messages like \"wip\" or \"missed a semicolon\". Every team has its own standards, for sure, but knowing how to squash your commits will make you look professional from your first pull request. If you get nothing else from this exercise, I would love it if you walked away knowing that you have the option of tidying up your commit history before anybody else looks at it.\n",
    "\n",
    "By now we've made quite a few piddling little commits. If we wanted someone else to review the things we've done, we can squash them into a smaller number of commits for simplicity of reviewing.\n",
    "\n",
    "### staging hunks with gitk\n",
    "\n",
    "## Stash\n",
    "\n",
    "## Rebase vs Merge\n",
    "\n",
    "https://www.quora.com/How-does-Git-merge-work/answer/Anders-Kaseorg\n",
    "\n",
    "## Bisect\n",
    "\n",
    "Bisect is a really useful thing that comes up in bigger, more complicated projects. The scenario where it makes sense is as follows: you have some code that works. You work on it some more, and you make multiple changes, over maybe dozens of commits. At some point, you notice that something doesn't work like it used to. You check out your last commit, and you find that it was broken there too. You roll back one more commit, and the thing that used to work is *still* broken. When did it last work? `git bisect` is for this.\n",
    "\n",
    "You give it a starting \"good\" commit and and ending \"bad\" commit, then do a binary search.\n",
    "https://git-scm.com/docs/git-bisect\n",
    "\n",
    "## `man git-<whatever>`: the manpages are your friend\n",
    "\n",
    "This is roughly the amount of knowledge that I have needed in order to be able to confidently read Git manpages. The trick is that even the manpages require insider knowledge to find them: to find out about `git pull`, you have to run `man git-pull` which is a pretty uncommon manpage naming format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "gitk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### `git log` revisited"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "First, let's see what the log shows us now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Sometimes it's handy to see a very summarized version of the log:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git log --oneline --topo-order --graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# 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": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### `git mv` and `rm`: moving and removing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git mv file1.txt file-newname.txt\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git commit -a -m\"I like this new name better\"\n",
    "echo \"Let's look at the log again:\"\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And `git rm` works in a similar fashion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Add a new file `file4.txt`, commit it, make some changes to it, commit them again, and then remove it (and don't forget to commit this last step!)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Local user, branching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "What is a branch?  Simply a *label for the 'current' commit in a sequence of ongoing commits*:\n",
    "\n",
    "<!-- offline: \n",
    "![](files/fig/masterbranch.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/masterbranch.png\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "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",
    "<!-- offline: \n",
    "![](files/fig/HEAD_testing.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/HEAD_testing.png\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Once new commits are made on a branch, HEAD and the branch label move with the new commits:\n",
    "\n",
    "<!-- offline: \n",
    "![](files/fig/branchcommit.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/branchcommit.png\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This allows the history of both branches to diverge:\n",
    "\n",
    "<!-- offline: \n",
    "![](files/fig/mergescenario.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/mergescenario.png\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "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",
    "<!-- offline: \n",
    "![](files/fig/mergeaftermath.png)\n",
    "-->\n",
    "\n",
    "<img src=\"https://raw.github.com/fperez/reprosw/master/fig/mergeaftermath.png\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's now illustrate all of this with a concrete example.  Let's get our bearings first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "git status\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "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": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "git branch experiment\n",
    "git checkout experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "echo \"Some crazy idea\" > experiment.txt\n",
    "git add experiment.txt\n",
    "git commit -a -m\"Trying something new\"\n",
    "git slog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "git checkout master\n",
    "git slog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "echo \"All the while, more work goes on in master...\" >> file-newname.txt\n",
    "git commit -a -m\"The mainline keeps moving\"\n",
    "git slog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git merge experiment\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using remotes as a single user"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We are now going to introduce the concept of a *remote repository*: a pointer to another copy of the repository that lives on a different location.  This can be simply a different path on the filesystem or a server on the internet.\n",
    "\n",
    "For this discussion, we'll be using remotes hosted on the [GitHub.com](http://github.com) service, but you can equally use other services like [BitBucket](http://bitbucket.org) or [Gitorious](http://gitorious.org) as well as host your own."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ls\n",
    "echo \"Let's see if we have any remote repositories here:\"\n",
    "git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Since the above cell didn't produce any output after the `git remote -v` call, it means we have no remote repositories configured.  We will now proceed to do so.  Once logged into GitHub, go to the [new repository page](https://github.com/new) and make a repository called `test`.  Do **not** check the box that says `Initialize this repository with a README`, since we already have an existing repository here.  That option is useful when you're starting first at Github and don't have a repo made already on a local computer.\n",
    "\n",
    "We can now follow the instructions from the next page:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git remote add origin https://github.com/mdcclv/test.git\n",
    "git push -u origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's see the remote situation again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can now [see this repository publicly on github](https://github.com/fperez/test).\n",
    "\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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cd ..\n",
    "# Here I clone my 'test' repo but with a different name, test2, to simulate a 2nd computer\n",
    "git clone https://github.com/mdcclv/test.git test2\n",
    "cd test2\n",
    "pwd\n",
    "git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's now make some changes in one 'computer' and synchronize them on the second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cd ../test2  # working on computer #2\n",
    "\n",
    "echo \"More new content on my experiment\" >> experiment.txt\n",
    "git commit -a -m\"More work, on machine #2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cd ../test2\n",
    "\n",
    "git push"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now let's fetch that work from machine #1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git pull"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### An important aside: conflict management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git branch trouble\n",
    "git checkout trouble\n",
    "echo \"This is going to be a problem...\" >> experiment.txt\n",
    "git commit -a -m\"Changes in the trouble branch\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And now we go back to the master branch, where we change the *same* file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git checkout master\n",
    "echo \"More work on the master branch...\" >> experiment.txt\n",
    "git commit -a -m\"Mainline work\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So now let's see what happens if we try to merge the `trouble` branch into `master`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git merge trouble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's see what git has put into our file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cat experiment.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "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": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cat experiment.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's then make our new commit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "git commit -a -m\"Completed merge of trouble, fixing conflicts along the way\"\n",
    "git slog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "*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.  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": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Collaborating on github with a small team"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Single remote with shared access: we are going to set up a shared collaboration with one partner (the person sitting next to you).  This will show the basic workflow of collaborating on a project with a small team where everyone has write privileges to the same repository.  \n",
    "\n",
    "Note for SVN users: this is similar to the classic SVN workflow, with the distinction that commit and push are separate steps.  SVN, having no local repository, commits directly to the shared central resource, so to a first approximation you can think of `svn commit` as being synonymous with `git commit; git push`.\n",
    "\n",
    "We will have two people, let's call them Alice and Bob, sharing a repository.  Alice will be the owner of the repo and she will give Bob write privileges.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We begin with a simple synchronization example, much like we just did above, but now between *two people* instead of one person.  Otherwise it's the same:\n",
    "\n",
    "- Bob clones Alice's repository.\n",
    "- Bob makes changes to a file and commits them locally.\n",
    "- Bob pushes his changes to github.\n",
    "- Alice pulls Bob's changes into her own repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Next, we will have both parties make non-conflicting changes each, and commit them locally.  Then both try to push their changes:\n",
    "\n",
    "- Alice adds a new file, `alice.txt` to the repo and commits.\n",
    "- Bob adds `bob.txt` and commits.\n",
    "- Alice pushes to github.\n",
    "- Bob tries to push to github.  What happens here?\n",
    "\n",
    "The problem is that Bob's changes create a commit that conflicts with Alice's, so git refuses to apply them.  It forces Bob to first do the merge on his machine, so that if there is a conflict in the merge, Bob deals with the conflict manually (git could try to do the merge on the server, but in that case if there's a conflict, the server repo would be left in a conflicted state without a human to fix things up).  The solution is for Bob to first pull the changes (pull in git is really fetch+merge), and then push again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Full-contact github: distributed collaboration with large teams"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Multiple remotes and merging based on pull request workflow: this is beyond the scope of this brief tutorial, so we'll simply discuss how it works very briefly, illustrating it with the activity on the [IPython github repository](http://github.com/ipython/ipython)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Other useful commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "- [show](http://www.kernel.org/pub/software/scm/git/docs/git-show.html)\n",
    "- [reflog](http://www.kernel.org/pub/software/scm/git/docs/git-reflog.html)\n",
    "- [rebase](http://www.kernel.org/pub/software/scm/git/docs/git-rebase.html)\n",
    "- [tag](http://www.kernel.org/pub/software/scm/git/docs/git-tag.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Git resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Introductory materials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "There are lots of good tutorials and introductions for Git, which you\n",
    "can easily find yourself; this is just a short list of things I've found\n",
    "useful.  For a beginner, I would recommend the following 'core' reading list, and\n",
    "below I mention a few extra resources:\n",
    "\n",
    "1. The smallest, and in the style of this tuorial: [git - the simple guide](http://rogerdudler.github.com/git-guide)\n",
    "contains 'just the basics'.  Very quick read.\n",
    "\n",
    "1.  The concise [Git Reference](http://gitref.org): compact but with\n",
    "    all the key ideas. If you only read one document, make it this one.\n",
    "\n",
    "1. In my own experience, the most useful resource was [Understanding Git\n",
    "Conceptually](http://www.sbf5.com/~cduan/technical/git).\n",
    "Git has a reputation for being hard to use, but I have found that with a\n",
    "clear view of what is actually a *very simple* internal design, its\n",
    "behavior is remarkably consistent, simple and comprehensible.\n",
    "\n",
    "1.  For more detail, see the start of the excellent [Pro\n",
    "    Git](http://progit.org/book) online book, or similarly the early\n",
    "    parts of the [Git community book](http://book.git-scm.com). Pro\n",
    "    Git's chapters are very short and well illustrated; the community\n",
    "    book tends to have more detail and has nice screencasts at the end\n",
    "    of some sections.\n",
    "\n",
    "If you are really impatient and just want a quick start, this [visual git tutorial](http://www.ralfebert.de/blog/tools/visual_git_tutorial_1)\n",
    "may be sufficient. It is nicely illustrated with diagrams that show what happens on the filesystem.\n",
    "\n",
    "For windows users, [an Illustrated Guide to Git on Windows](http://nathanj.github.com/gitguide/tour.html) is useful in that\n",
    "it contains also some information about handling SSH (necessary to interface with git hosted on remote servers when collaborating) as well\n",
    "as screenshots of the Windows interface.\n",
    "\n",
    "Cheat sheets\n",
    ":   Two different\n",
    "    [cheat](http://zrusin.blogspot.com/2007/09/git-cheat-sheet.html)\n",
    "    [sheets](http://jan-krueger.net/development/git-cheat-sheet-extended-edition)\n",
    "    in PDF format that can be printed for frequent reference."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Beyond the basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "At some point, it will pay off to understand how git itself is *built*.  These two documents, written in a similar spirit, \n",
    "are probably the most useful descriptions of the Git architecture short of diving into the actual implementation.  They walk you through\n",
    "how you would go about building a version control system with a little story. By the end you realize that Git's model is almost\n",
    "an inevitable outcome of the proposed constraints:\n",
    "\n",
    "* The [Git parable](http://tom.preston-werner.com/2009/05/19/the-git-parable.html) by Tom Preston-Werner.\n",
    "* [Git foundations](http://matthew-brett.github.com/pydagogue/foundation.html) by Matthew Brett.\n",
    "\n",
    "[Git ready](http://www.gitready.com)\n",
    ":   A great website of posts on specific git-related topics, organized\n",
    "    by difficulty.\n",
    "\n",
    "[QGit](http://sourceforge.net/projects/qgit/): an excellent Git GUI\n",
    ":   Git ships by default with gitk and git-gui, a pair of Tk graphical\n",
    "    clients to browse a repo and to operate in it. I personally have\n",
    "    found [qgit](http://sourceforge.net/projects/qgit/) to be nicer and\n",
    "    easier to use. It is available on modern linux distros, and since it\n",
    "    is based on Qt, it should run on OSX and Windows.\n",
    "\n",
    "[Git Magic](http://www-cs-students.stanford.edu/~blynn/gitmagic/index.html)\n",
    ":   Another book-size guide that has useful snippets.\n",
    "\n",
    "The [learning center](http://learn.github.com) at Github\n",
    ":   Guides on a number of topics, some specific to github hosting but\n",
    "    much of it of general value.\n",
    "\n",
    "A [port](http://cworth.org/hgbook-git/tour) of the Hg book's beginning\n",
    ":   The [Mercurial book](http://hgbook.red-bean.com) has a reputation\n",
    "    for clarity, so Carl Worth decided to\n",
    "    [port](http://cworth.org/hgbook-git/tour) its introductory chapter\n",
    "    to Git. It's a nicely written intro, which is possible in good\n",
    "    measure because of how similar the underlying models of Hg and Git\n",
    "    ultimately are.\n",
    "\n",
    "[Intermediate tips](http://andyjeffries.co.uk/articles/25-tips-for-intermediate-git-users)\n",
    ":   A set of tips that contains some very valuable nuggets, once you're\n",
    "    past the basics.\n",
    "\n",
    "Finally, if you prefer a video presentation, this 1-hour tutorial prepared by the GitHub educational team will walk you through the entire process:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%%python\n",
    "\n",
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('U8GBXvdmHT4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### A few useful tips for common tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Better shell support\n",
    "\n",
    "Adding git branch info to your bash prompt and tab completion for git commands and branches is extremely useful.  I suggest you at least copy:\n",
    "\n",
    "- [git-completion.bash](https://github.com/git/git/blob/master/contrib/completion/git-completion.bash)\n",
    "- [git-prompt.sh](https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh)\n",
    " \n",
    "You can then source both of these files in your `~/.bashrc` and then set your prompt (I'll assume you named them as the originals but starting with a `.` at the front of the name):\n",
    "\n",
    "    source $HOME/.git-completion.bash\n",
    "    source $HOME/.git-prompt.sh\n",
    "    PS1='[\\u@\\h \\W$(__git_ps1 \" (%s)\")]\\$ '   # adjust this to your prompt liking\n",
    "\n",
    "See the comments in both of those files for lots of extra functionality they offer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Embedding Git information in LaTeX documents\n",
    "\n",
    "(Sent by [Yaroslav Halchenko](http://www.onerussian.com))\n",
    "su\n",
    "I use a Make rule:\n",
    "\n",
    "    # Helper if interested in providing proper version tag within the manuscript\n",
    "    revision.tex: ../misc/revision.tex.in ../.git/index\n",
    "       GITID=$$(git log -1 | grep -e '^commit' -e '^Date:' | sed  -e 's/^[^ ]* *//g' | tr '\\n' ' '); \\\n",
    "       echo $$GITID; \\\n",
    "       sed -e \"s/GITID/$$GITID/g\" $< >| $@\n",
    "\n",
    "in the top level `Makefile.common` which is included in all\n",
    "subdirectories which actually contain papers (hence all those\n",
    "`../.git`). The `revision.tex.in` file is simply:\n",
    "\n",
    "    % Embed GIT ID revision and date\n",
    "    \\def\\revision{GITID}\n",
    "\n",
    "The corresponding `paper.pdf` depends on `revision.tex` and includes the\n",
    "line `\\input{revision}` to load up the actual revision mark."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### git export\n",
    "\n",
    "Git doesn't have a native export command, but this works just fine:\n",
    "\n",
    "    git archive --prefix=fperez.org/  master | gzip > ~/tmp/source.tgz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}