Updates for final day

Author: fperez

01-Intro Jupyter Notebook.ipynb

@@ -98,18 +98,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Through IPython's kernel and messaging architecture, the Notebook allows code to be run in a range of different programming languages.  For each notebook document that a user opens, the web application starts a kernel that runs the code for that notebook. Each kernel is capable of running code in a single programming language and there are kernels available in over [100 programming languages](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels); some of the most popular are:\n",
+    "Through IPython's kernel and messaging architecture, the Notebook allows code to be run in a range of different programming languages.  For each notebook document that a user opens, the web application starts a kernel that runs the code for that notebook. Each kernel is capable of running code in a single programming language and there are kernels available in over [100 programming languages](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels).\n",
     "\n",
-    "* Python(https://github.com/ipython/ipython)\n",
-    "* Julia (https://github.com/JuliaLang/IJulia.jl)\n",
-    "* R (https://github.com/takluyver/IRkernel)\n",
-    "* Ruby (https://github.com/minrk/iruby)\n",
-    "* Haskell (https://github.com/gibiansky/IHaskell)\n",
-    "* Scala (https://github.com/Bridgewater/scala-notebook)\n",
-    "* node.js (https://gist.github.com/Carreau/4279371)\n",
-    "* Go (https://github.com/takluyver/igo)\n",
-    "\n",
-    "The default kernel runs Python code. \n",
+    "[IPython](https://github.com/ipython/ipython) is the default kernel, it runs Python code.\n",
     "\n",
     "Each of these kernels communicate with the notebook web application and web browser using a JSON over ZeroMQ/WebSockets message protocol that is described [here](https://jupyter-client.readthedocs.io/en/latest/messaging.html#messaging). Most users don't need to know about these details, but it helps to understand that \"kernels run code.\""
    ]
@@ -156,6 +147,85 @@
     "Furthermore, any notebook document available from a **public URL on or GitHub can be shared** via http://nbviewer.jupyter.org. This service loads the notebook document from the URL and renders it as a static web page. The resulting web page may thus be shared with others **without their needing to install Jupyter**."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Body\n",
+    "\n",
+    "The body of a notebook is composed of cells. Each cell contains either markdown, code input, code output, or raw text. Cells can be included in any order and edited at-will, allowing for a large ammount of flexibility for constructing a narrative.\n",
+    "\n",
+    "- **Markdown cells** - These are used to build a nicely formatted narrative around the code in the document. The majority of this lesson is composed of markdown cells.\n",
+    "\n",
+    "- **Code cells** - These are used to define the computational code in the document. They come in two forms: the *input cell* where the user types the code to be executed, and the *output cell* which is the representation of the executed code. Depending on the code, this representation may be a simple scalar value, or something more complex like a plot or an interactive widget.\n",
+    "\n",
+    "- **Raw cells** - These are used when text needs to be included in raw form, without execution or transformation.\n",
+    "\n",
+    "This is what the three types of cells look like:\n",
+    "\n",
+    "<img src=\"images/cell_types.png\" />"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Modality\n",
+    "\n",
+    "The notebook user interface is *modal*. This means that the keyboard behaves differently depending upon the current mode of the notebook. A notebook has two modes: **edit** and **command**.\n",
+    "\n",
+    "**Edit mode** is indicated by a blue cell border and a prompt showing in the editor area. When a cell is in edit mode, you can type into the cell, like a normal text editor.\n",
+    "\n",
+    "<img src=\"images/edit_mode.png\">\n",
+    "\n",
+    "**Command mode** is indicated by a grey cell background. When in command mode, the structure of the notebook can be modified as a whole, but the text in individual cells cannot be changed. Most importantly, the keyboard is mapped to a set of shortcuts for efficiently performing notebook and cell actions. For example, pressing **`c`** when in command mode, will copy the current cell; no modifier is needed.\n",
+    "\n",
+    "<img src=\"images/command_mode.png\">\n",
+    "\n",
+    "Enter edit mode by pressing `Enter` or using the mouse to click on a cell's editor area.\n",
+    "\n",
+    "Enter command mode by pressing `Esc` or using the mouse to click *outside* a cell's editor area.\n",
+    "\n",
+    "Do not attempt to type into a cell when in command mode; unexpected things will happen!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Mouse navigation\n",
+    "\n",
+    "The first concept to understand in mouse-based navigation is that **cells can be selected by clicking on them.** The currently selected cell is indicated with a blue outline or gray background depending on whether the notebook is in edit or command mode. Clicking inside a cell's editor area will enter edit mode. Clicking on the prompt or the output area of a cell will enter command mode.\n",
+    "\n",
+    "The second concept to understand in mouse-based navigation is that **cell actions usually apply to the currently selected cell**. For example, to run the code in a cell, select it and then click the <button class='btn btn-default btn-xs'><i class=\"fa fa-play icon-play\"></i></button> button in the toolbar or the **`Run -> Run Selected Cells`** menu item. Similarly, to copy a cell, select it and then click the <button class='btn btn-default btn-xs'><i class=\"fa fa-copy icon-copy\"></i></button> button in the toolbar or the **`Edit -> Copy`** menu item. With this simple pattern, it should be possible to perform nearly every action with the mouse.\n",
+    "\n",
+    "Markdown cells have one other state which can be modified with the mouse. These cells can either be rendered or unrendered. When they are rendered, a nice formatted representation of the cell's contents will be presented. When they are unrendered, the raw text source of the cell will be presented. To render the selected cell with the mouse, click the <button class='btn btn-default btn-xs'><i class=\"fa fa-play icon-play\"></i></button> button in the toolbar or the **`Run -> Run Selected Cells`** menu item. To unrender the selected cell, double click on the cell."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Keyboard Navigation\n",
+    "\n",
+    "The modal user interface of the IPython Notebook has been optimized for efficient keyboard usage. This is made possible by having two different sets of keyboard shortcuts: one set that is active in edit mode and another in command mode.\n",
+    "\n",
+    "The most important keyboard shortcuts are **`Enter`**, which enters edit mode, and **`Esc`**, which enters command mode.\n",
+    "\n",
+    "In edit mode, most of the keyboard is dedicated to typing into the cell's editor. Thus, in edit mode there are relatively few shortcuts. In command mode, the entire keyboard is available for shortcuts, so there are many more possibilities.\n",
+    "\n",
+    "The following shortcuts have been found to be the most useful in day-to-day tasks:\n",
+    "\n",
+    "- Basic navigation: **`enter`**, **`shift-enter`**, **`up/k`**, **`down/j`**\n",
+    "- Saving the notebook: **`s`**\n",
+    "- Cell types: **`y`**, **`m`**, **`r`**\n",
+    "- Cell creation: **`a`**, **`b`**\n",
+    "- Cell editing: **`x`**, **`c`**, **`v`**, **`d`**, **`z`**, **`ctrl+shift+-`**\n",
+    "- Kernel operations: **`i`**, **`.`**\n",
+    "\n",
+    "You can fully customize JupyterLab's keybindings by accessing the **`Settings -> Advanced Settings Editor`** menu item."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -361,7 +431,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "All output is displayed asynchronously as it is generated in the Kernel. If you execute the next cell, you will see the output one piece at a time, not all at the end."
+    "All output is displayed as it is generated in the Kernel: instead of blocking on the execution of the entire cell, output is made available to the Notebook immediately as it is generated by the kernel (even though the whole cell is submitted for execution as a single unit).\n",
+    "\n",
+    "If you execute the next cell, you will see the output one piece at a time, not all at the end:"
    ]
   },
   {

02-Beyond Plain Python.ipynb

@@ -366,7 +366,7 @@
    "source": [
     "The IPyhton 'magic' functions are a set of commands, invoked by prepending one or two `%` signs to their name, that live in a namespace separate from your normal Python variables and provide a more command-like interface.  They take flags with `--` and arguments without quotes, parentheses or commas. The motivation behind this system is two-fold:\n",
     "    \n",
-    "- To provide an orthogonal namespace for controlling IPython itself and exposing other system-oriented functionality.\n",
+    "- To provide an namespace for controlling IPython itself and exposing other system-oriented functionality that is separate from your Python variables and functions.  This lets you have a `cd` command accessible as a magic regardless of whether you have a Python `cd` variable.\n",
     "\n",
     "- To expose a calling mode that requires minimal verbosity and typing while working interactively.  Thus the inspiration taken from the classic Unix shell style for commands."
    ]
@@ -384,7 +384,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Line vs cell magics:"
+    "Line vs cell magics:\n",
+    "\n",
+    "Magics can be applied at the single-line level or to entire cells. Line magics are identified with a single `%` prefix, while cell magics use `%%` and can only be used as the first line of the cell (since they apply to the entire cell). Some magics, like the convenient `%timeit` that ships built-in with IPython, can be called in either mode, while others may be line- or cell-only (you can see all magics with `%lsmagic`).\n",
+    "\n",
+    "Let's see this with some `%timeit` examples:"
    ]
   },
   {
@@ -430,7 +434,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Magics can do anything they want with their input, so it doesn't have to be valid Python:"
+    "Magics can do anything they want with their input, so it doesn't have to be valid Python (note that the below may not work on a Windows machine, depending on how you are running Jupyter on it):"
    ]
   },
   {

binder-overview.pdf

@@ -19,7 +19,6 @@
     "3. Jupyter revisited: collaboration and reproducibility (1:30 h)\n",
     "   1. Rich output in IPython.\n",
     "   1. Jupyter Widgets for interactivity\n",
-    "   1. An overview of JupyterHub\n",
     "   1. Binder overview (Docker, creating a basic Binder-compliant repo)."
    ]
   },