2016-07-27-notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# UBC Scientific Software Seminar\n",
    "\n",
    "## July 27, 2016\n",
    "\n",
    "Today's Agenda:\n",
    "\n",
    "1. Git/GitHub: clone, push and pull, and collaborate\n",
    "2. Bash: commands for navigating the Linux file system\n",
    "3. Python datatypes: `int`, `float`, `str`, `list`, `bool`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Git and GitHub\n",
    "\n",
    "[Git](https://git-scm.com/) is open source, version control software for managing software projects. [GitHub](https://github.com) is a website which hosts Git repositories and facilitates open source software collaboration.\n",
    "\n",
    "Although it is possible to edit files in a repository on GitHub itself, most work is done locally (ie. on your own machine - for example, your JupyterHub account) and then changes are pushed and pulled from GitHub to your local Git repository. See [GitHub Help](https://help.github.com/) for plenty of resources on using Git and GitHub.\n",
    "\n",
    "In the exercise below, we will collaborate on GitHub following the GitHub collaborator workflow:\n",
    "\n",
    "* A central user (ie. patrickwalls) creates a repository in their GitHub account\n",
    "* The central user adds collaborators to the repository by their username\n",
    "* Collaborators clone the GitHub repository from the central user to their own machines\n",
    "* Collaborators make changes locally and push them to GitHub\n",
    "* Collaborators pull other people's changes from GitHub to their local machine\n",
    "* Communications, conflicts and ideas are shared in the issues tab of the GitHub repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.1: Collaborating on GitHub\n",
    "\n",
    "`patrickwalls` created a repository on GitHub for us to share resources for the seminar:\n",
    "\n",
    "```\n",
    "http://github.com/patrickwalls/ubcs3-resources\n",
    "```\n",
    "\n",
    "1. Become a collaborator for the repository:\n",
    "    * Go to the issues tab of the repository and post a message on the issue titled \"Looking for collaborators!\"\n",
    "    * `patrickwalls` will add your username to the list of collaborators\n",
    "    * You now have push access to the repository\n",
    "2. Clone the GitHub repository to your JupyterHub account:\n",
    "    * Login to JupyterHub\n",
    "    * Open a new terminal\n",
    "    * Enter the command `git clone https://github.com/patrickwalls/ubcs3-resources.git`\n",
    "3. Make a contribution and push it to GitHub:\n",
    "    * On JupyterHub, create a .md file which introduces an online resource you think would be helpful to others\n",
    "    * To avoid conflicts, let's all name our files in the form `username-resource.md`. For example, to share [Visualizing Git with D3](https://onlywei.github.io/explain-git-with-d3/), I would name my file `patrickwalls-visualizing-git.md` and save it to the `git-resources` folder in the repo.\n",
    "    * In the terminal, navigate to your cloned repo and push your contribution to GitHub by entering these commands:\n",
    "        * Add your changes to the staging area: `git add <filename>`\n",
    "        * Commit your changes: `git commit -m \"Added resource for ... \"`\n",
    "        * Push your changes: `git push origin master`\n",
    "            * If someone has pushed changes since the last time you pulled in from the GitHub repo, you must enter the command `git pull` to update your local repo before you can push your changes\n",
    "            * If you pull changes after you have made changes to your local repo, the commmand `git pull` performs a merge and Git will open the Emacs text editor and require you to write a merge commit message\n",
    "            * In Emacs, you can simply enter `CTRL-x CTRL-s` to save the default commit message and then `CTRL-x CTRL-c` to exit\n",
    "4. Pull everyone's changes from GitHub to your cloned repo on JupyterHub:\n",
    "    * In the terminal, navigate to your cloned repo and enter the command `git pull`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Bash\n",
    "\n",
    "The [Bash shell](https://www.gnu.org/software/bash/) is a program on a Linux machine where the user types commands to interact with the Linux operating system. There are *many* powerful Bash commands designed for different purposes:\n",
    "\n",
    "* navigating the file system\n",
    "* creating and deleting elements in the file system\n",
    "* finding files and directories in the file system\n",
    "* editing and manipulating files and directories\n",
    "* setting permissions on files and directories\n",
    "* managing users and networks\n",
    "* et cetera\n",
    "\n",
    "At the moment, we will only consider the most common Bash commands (see the [Bash Shell Cheat Sheet](http://cli.learncodethehardway.org/bash_cheat_sheet.pdf)):\n",
    "\n",
    "* `pwd` – print working directory\n",
    "* `ls` – list contents of the working directory\n",
    "* `mkdir <directoryname>` – create a new directory\n",
    "* `cd <directoryname>` – navigate into the specified directory\n",
    "* `less <filename>` – view the contents of a file\n",
    "* `cat <filename>` – display contents of a file in the terminal\n",
    "* `head <filename>` - display the top 10 lines of a file\n",
    "  * `head -n <filename>` to display the top `n` lines\n",
    "* `tail <filename>` - display the last 10 lines of a file\n",
    "  * `tail -n <filename>` to display the last `n` lines\n",
    "* `rm <filename>` – delete a file (immediately and permanently!)\n",
    "* `mv <filename> <destination>` - move (or rename) a file\n",
    "* `wc <filename>` – show the number of lines, words, bytes or characters in a file\n",
    "* `sort <filename>` – sort the contents of a file\n",
    "* `curl <url>` – retrieve and output the contents of the file located at the specified URL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.1: Exploring the Git repository\n",
    "\n",
    "Open a new terminal in JupyterHub and enter the following commands:\n",
    "\n",
    "* Orient yourself in the file system:\n",
    "    * `pwd`\n",
    "    * `ls`\n",
    "* Navigate into the Git repo cloned in Exercise 1.1 above and view its contents:\n",
    "    * `cd ubcs3-resources`\n",
    "    * `ls`\n",
    "* One directory at a time, navigate into the directory, list its contents, view a file and navigate back to the directory above it:\n",
    "    * `cd git-resources`\n",
    "    * `ls`\n",
    "    * `less patrickwalls-visualizing-git.md`\n",
    "    * `cd ..`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.2: Sorting word counts in text files\n",
    "\n",
    "* Navigate to the `git-resources` directory in the `ubcs3-resources` directory\n",
    "* Choose a file and enter the commmand `wc <filename>` to see the number of lines, words and characters in the file\n",
    "* Enter the command `wc -w *.md` to see the number of words in each file in the current directory which end in `.md`\n",
    "    * The asterisk is called a [wildcard](http://www.linfo.org/wildcard.html) and the expression `*.md` translates to \"any file ending in `.md`\"\n",
    "    * The option `-w` is called a flag and specifies the option to only show the number of words in the file\n",
    "* Finally, to order the files in terms of the words in each file, enter the command `wc -w *.md | sort -n`\n",
    "    * The character `|` is a [pipe](http://www.linfo.org/pipe.html) and takes the output from the first command `wc -w *.md` and uses it as input into the second command `sort -n`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Python\n",
    "\n",
    "### Datatypes\n",
    "\n",
    "There are several built in datatypes in Python. See the [Python 3 documentation](https://docs.python.org/3/library/stdtypes.html) for a complete list of types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integers - `int`\n",
    "\n",
    "Here are a few examples of operations involving integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "91"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 * 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 / 2 # division always returns a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 // 2 # floor division rounds down to the nearest integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1 + 2) # check the type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Floats - `float`\n",
    "\n",
    "Notice that in Python 3 division involving integers always returns a float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 / 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More examples of operations involving floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3.14159)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings - `str`\n",
    "\n",
    "Strings are sequences of characters enclosed in (single or double) quotes. Here are some operations involving strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'helloworld'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\" + \"world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hellohellohello'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\" * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"howdy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists -  `list`\n",
    "\n",
    "Lists are ordered sequences of arbitrary Python objects. We use brackets and commas (ie. `[1,2,3]`) to define lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'one', 1.0]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,\"one\",1.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3,4] + [5,6,7,8] + [9,10,11,12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(['h','e','l','l','o'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean - `bool`\n",
    "\n",
    "Boolean type consists of `True` and `False`. The usual [comparison operators](https://docs.python.org/3/library/stdtypes.html#comparisons) `<`, `>`, `<=`, `>=`, `==`, `!=` along with the [boolean operators](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not) `and`, `or`, `not` produce boolean types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello' != 'hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * 8 == 4 * 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}