Lab0-beginners-guide/01-jupyter-notebook-markdown-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`01-jupyter-notebook-markdown-basics` (a.l. 2021-04-13)\n",
    "\n",
    "**Jupyter notebook markdown - users manual**\n",
    "\n",
    "(modified and extended from the Jupyter Project at [Bryn Mawr College](https://www.brynmawr.edu) - https://jupyter.brynmawr.edu/hub)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/computational-medicine/BMED360-2021/blob/main/Lab0-beginners-guide/01-jupyter-notebook-markdown-basics.ipynb\">\n",
    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This page describes the functionality of the [Jupyter](http://jupyter.org) electronic document system. Jupyter documents are called \"notebooks\" and can be seen as many things at once (see also the [Executable Book Project](#8.-The-executable-book-project)). For example, notebooks allow:\n",
    "\n",
    "* creation in a **standard web browser**\n",
    "* direct **sharing**\n",
    "* using **text with styles** (such as italics and titles) to be explicitly marked using a [wikitext language](http://en.wikipedia.org/wiki/Wiki_markup)\n",
    "* easy creation and display of beautiful **equations**\n",
    "* creation and execution of interactive embedded **computer programs**\n",
    "* easy creation and display of **interactive visualizations**\n",
    "\n",
    "Jupyter notebooks (previously called \"IPython notebooks\") are thus interesting and useful to different groups of people:\n",
    "\n",
    "* readers who want to view and execute computer programs\n",
    "* authors who want to create executable documents or documents with visualizations\n",
    "\n",
    "<hr size=\"5\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Table of Contents\n",
    "* [1. Getting to Know your Jupyter Notebook's Toolbar](#1.-Getting-to-Know-your-Jupyter-Notebook's-Toolbar)\n",
    "* [2. Different Kinds of Cells](#2.-Different-Kinds-of-Cells)\n",
    "\t* [2.1 Code Cells](#2.1-Code-Cells)\n",
    "\t\t* [2.1.1 Code Cell Layout](#2.1.1-Code-Cell-Layout)\n",
    "\t\t\t* [2.1.1.1 Row Configuration (Default Setting)](#2.1.1.1-Row-Configuration-%28Default-Setting%29)\n",
    "\t\t\t* [2.1.1.2 Cell Tabbing](#2.1.1.2-Cell-Tabbing)\n",
    "\t\t\t* [2.1.1.3 Column Configuration](#2.1.1.3-Column-Configuration)\n",
    "\t* [2.2 Markdown Cells](#2.2-Markdown-Cells)\n",
    "\t* [2.3 Raw Cells](#2.3-Raw-Cells)\n",
    "\t* [2.4 Header Cells](#2.4-Header-Cells)\n",
    "\t\t* [2.4.1 Linking](#2.4.1-Linking)\n",
    "\t\t* [2.4.2 Automatic Section Numbering and Table of Contents Support](#2.4.2-Automatic-Section-Numbering-and-Table-of-Contents-Support)\n",
    "\t\t\t* [2.4.2.1 Automatic Section Numbering](#2.4.2.1-Automatic-Section-Numbering)\n",
    "\t\t\t* [2.4.2.2 Table of Contents Support](#2.4.2.2-Table-of-Contents-Support)\n",
    "\t\t\t* [2.4.2.3 Using Both Automatic Section Numbering and Table of Contents Support](#2.4.2.3-Using-Both-Automatic-Section-Numbering-and-Table-of-Contents-Support)\n",
    "* [3. Keyboard Shortcuts](#3.-Keyboard-Shortcuts)\n",
    "* [4. Using Markdown Cells for Writing](#4.-Using-Markdown-Cells-for-Writing)\n",
    "\t* [4.1 Block Elements](#4.1-Block-Elements)\n",
    "\t\t* [4.1.1 Paragraph Breaks](#4.1.1-Paragraph-Breaks)\n",
    "\t\t* [4.1.2 Line Breaks](#4.1.2-Line-Breaks)\n",
    "\t\t\t* [4.1.2.1 Hard-Wrapping and Soft-Wrapping](#4.1.2.1-Hard-Wrapping-and-Soft-Wrapping)\n",
    "\t\t\t* [4.1.2.2 Soft-Wrapping](#4.1.2.2-Soft-Wrapping)\n",
    "\t\t\t* [4.1.2.3 Hard-Wrapping](#4.1.2.3-Hard-Wrapping)\n",
    "\t\t* [4.1.3 Headers](#4.1.3-Headers)\n",
    "\t\t* [4.1.4 Block Quotes](#4.1.4-Block-Quotes)\n",
    "\t\t\t* [4.1.4.1 Standard Block Quoting](#4.1.4.1-Standard-Block-Quoting)\n",
    "\t\t\t* [4.1.4.2 Nested Block Quoting](#4.1.4.2-Nested-Block-Quoting)\n",
    "\t\t* [4.1.5 Lists](#4.1.5-Lists)\n",
    "\t\t\t* [4.1.5.1 Ordered Lists](#4.1.5.1-Ordered-Lists)\n",
    "\t\t\t* [4.1.5.2 Bulleted Lists](#4.1.5.2-Bulleted-Lists)\n",
    "\t\t* [4.1.6 Section Breaks](#4.1.6-Section-Breaks)\n",
    "\t* [4.2 Backslash Escape](#4.2-Backslash-Escape)\n",
    "\t* [4.3 Hyperlinks](#4.3-Hyperlinks)\n",
    "\t\t* [4.3.1 Automatic Links](#4.3.1-Automatic-Links)\n",
    "\t\t* [4.3.2 Standard Links](#4.3.2-Standard-Links)\n",
    "\t\t* [4.3.3 Standard Links With Mouse-Over Titles](#4.3.3-Standard-Links-With-Mouse-Over-Titles)\n",
    "\t\t* [4.3.4 Reference Links](#4.3.4-Reference-Links)\n",
    "\t\t* [4.3.5 Notebook-Internal Links](#4.3.5-Notebook-Internal-Links)\n",
    "\t\t\t* [4.3.5.1 Standard Notebook-Internal Links Without Mouse-Over Titles](#4.3.5.1-Standard-Notebook-Internal-Links-Without-Mouse-Over-Titles)\n",
    "\t\t\t* [4.3.5.2 Standard Notebook-Internal Links With Mouse-Over Titles](#4.3.5.2-Standard-Notebook-Internal-Links-With-Mouse-Over-Titles)\n",
    "\t\t\t* [4.3.5.3 Reference-Style Notebook-Internal Links](#4.3.5.3-Reference-Style-Notebook-Internal-Links)\n",
    "\t* [4.4 Tables](#4.4-Tables)\n",
    "\t\t* [4.4.1 Cell Justification](#4.4.1-Cell-Justification)\n",
    "\t* [4.5 Style and Emphasis](#4.5-Style-and-Emphasis)\n",
    "\t* [4.6 Other Characters](#4.6-Other-Characters)\n",
    "\t* [4.7 Including Code Examples](#4.7-Including-Code-Examples)\n",
    "\t* [4.8 Images](#4.8-Images)\n",
    "\t\t* [4.8.1 Images from the Internet](#4.8.1-Images-from-the-Internet)\n",
    "\t\t\t* [4.8.1.1 Reference-Style Images from the Internet](#4.8.1.1-Reference-Style-Images-from-the-Internet)\n",
    "\t* [4.9 LaTeX Math](#4.9-LaTeX-Math)\n",
    "* [5. Bibliographic Support](#5.-Bibliographic-Support)\n",
    "\t* [5.1 Creating a Bibtex Database](#5.1-Creating-a-Bibtex-Database)\n",
    "\t\t* [5.1.1 External Bibliographic Databases](#5.1.1-External-Bibliographic-Databases)\n",
    "\t\t* [5.1.2 Internal Bibliographic Databases](#5.1.2-Internal-Bibliographic-Databases)\n",
    "\t\t\t* [5.1.2.1 Hiding Your Internal Database](#5.1.2.1-Hiding-Your-Internal-Database)\n",
    "\t\t* [5.1.3 Formatting Bibtex Entries](#5.1.3-Formatting-Bibtex-Entries)\n",
    "\t* [5.2 Cite Commands and Citation IDs](#5.2-Cite-Commands-and-Citation-IDs)\n",
    "* [6. Turning Your Jupyter Notebook into a Slideshow](#6.-Turning-Your-Jupyter-Notebook-into-a-Slideshow)\n",
    "* [7. nbdev](#7.-nbdev)\n",
    "* [8. The executable book project](#8.-The-executable-book-project)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Getting to Know your Jupyter Notebook's Toolbar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "At the top of your Jupyter Notebook window there is a toolbar. It looks like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![](images/jupytertoolbar.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Below is a table which helpfully pairs a picture of each of the items in your toolbar with a corresponding explanation of its function. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Button|Function\n",
    "-|-\n",
    "![](./assets/jupytertoolbarsave.png)|This is your save button. You can click this button to save your notebook at any time, though keep in mind that Jupyter Notebooks automatically save your progress very frequently.  \n",
    "![](assets/jupytertoolbarnewcell.png)|This is the new cell button. You can click this button any time you want a new cell in your Jupyter Notebook. \n",
    "![](assets/jupytertoolbarcutcell.png)|This is the cut cell button. If you click this button, the cell you currently have selected will be deleted from your Notebook. \n",
    "![](assets/jupytertoolbarcopycell.png)|This is the copy cell button. If you click this button, the currently selected cell will be duplicated and stored in your clipboard. \n",
    "![](assets/jupytertoolbarpastecell.png)|This is the past button. It allows you to paste the duplicated cell from your clipboard into your notebook. \n",
    "![](assets/jupytertoolbarupdown.png)|These buttons allow you to move the location of a selected cell within a Notebook. Simply select the cell you wish to move and click either the up or down button until the cell is in the location you want it to be.\n",
    "![](assets/jupytertoolbarrun.png)|This button will \"run\" your cell, meaning that it will interpret your input and render the output in a way that depends on [what kind of cell] [cell kind] you're using. \n",
    "![](assets/jupytertoolbarstop.png)|This is the stop button. Clicking this button will stop your cell from continuing to run. This tool can be useful if you are trying to execute more complicated code, which can sometimes take a while, and you want to edit the cell before waiting for it to finish rendering. \n",
    "![](assets/jupytertoolbarrestartkernel.png)|This is the restart kernel button. See your kernel documentation for more information.\n",
    "![](assets/jupytertoolbarcellkind.png)|This is a drop down menu which allows you to tell your Notebook how you want it to interpret any given cell. You can read more about the [different kinds of cells] [cell kind] in the following section. \n",
    "![](assets/jupytertoolbartoolbartype.png)|Individual cells can have their own toolbars. This is a drop down menu from which you can select the type of toolbar that you'd like to use with the cells in your Notebook. Some of the options in the cell toolbar menu will only work in [certain kinds of cells][cell kind]. \"None,\" which is how you specify that you do not want any cell toolbars, is the default setting. If you select \"Edit Metadata,\" a toolbar that allows you to edit data about [Code Cells][code cells] directly will appear in the corner of all the Code cells in your notebook. If you select \"Raw Cell Format,\" a tool bar that gives you several formatting options will appear in the corner of all your [Raw Cells][raw cells]. If you want to view and present your notebook as a slideshow, you can select \"Slideshow\" and a toolbar that enables you to organize your cells in to slides, sub-slides, and slide fragments will appear in the corner of every cell. Go to [this section][slideshow] for more information on how to create a slideshow out of your Jupyter Notebook. \n",
    "![](assets/jupytertoolbarsectionmove.png)|These buttons allow you to move the location of an entire section within a Notebook. Simply select the Header Cell for the section or subsection you wish to move and click either the up or down button until the section is in the location you want it to be. If your have used [Automatic Section Numbering][section numbering] or [Table of Contents Support][table of contents] remember to rerun those tools so that your section numbers or table of contents reflects your Notebook's new organization. \n",
    "![](assets/jupytertoolbarsectionnumbering.png)|Clicking this button will automatically number your Notebook's sections. For more information, check out the Reference Guide's [section on Automatic Section Numbering][section numbering].\n",
    "![](assets/jupytertoolbartableofcontents.png)|Clicking this button will generate a table of contents using the titles you've given your Notebook's sections. For more information, check out the Reference Guide's [section on Table of Contents Support][table of contents].\n",
    "![](assets/jupytertoolbarbib.png)|Clicking this button will search your document for [cite commands][] and automatically generate intext citations as well as a references cell at the end of your Notebook. For more information, you can read the Reference Guide's [section on Bibliographic Support][bib support].\n",
    "![](assets/jupytertoolbartab.png)|Clicking this button will toggle [cell tabbing][], which you can learn more about in the Reference Guides' [section on the layout options for Code Cells][cell layout].\n",
    "![](assets/jupytertoolbarcollumn.png)|Clicking this button will toggle the [collumn configuration][] for Code Cells, which you can learn more about in the Reference Guides' [section on the layout options for Code Cells][cell layout].\n",
    "![](assets/jupytertoolbarspellcheck.png)|Clicking this button will toggle spell checking. Spell checking only works in unrendered [Markdown Cells][] and [Header Cells][]. When spell checking is on all incorrectly spelled words will be underlined with a red squiggle. Keep in mind that the dictionary cannot tell what are [Markdown][md writing] commands and what aren't, so it will occasionally underline a correctly spelled word surrounded by asterisks, brackets, or other symbols that have specific meaning in Markdown. \n",
    "\n",
    "\n",
    "[cell kind]: #2.-Different-Kinds-of-Cells \"Different Kinds of Cells\"\n",
    "[code cells]: #2.1-Code-Cells \"Code Cells\"\n",
    "[raw cells]: #2.3-Raw-Cells \"Raw Cells\"\n",
    "[slideshow]: #6.-Turning-Your-Jupyter-Notebook-into-a-Slideshow \"Turning Your Jupyter Notebook Into a Slideshow\"\n",
    "[section numbering]: #2.4.2.1-Automatic-Section-Numbering\n",
    "[table of contents]: #2.4.2.2-Table-of-Contents-Support\n",
    "[cell tabbing]: #2.1.1.2-Cell-Tabbing\n",
    "[cell layout]: #2.1.1-Code-Cell-Layout\n",
    "[bib support]: #5.-Bibliographic-Support\n",
    "[cite commands]: #5.2-Cite-Commands-and-Citation-IDs\n",
    "[md writing]: #4.-Using-Markdown-Cells-for-Writing\n",
    "[collumn configuration]: #2.1.1.3-Column-Configuration\n",
    "[Markdown Cells]: #2.2-Markdown-Cells\n",
    "[Header Cells]: #2.4-Header-Cells\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 2. Different Kinds of Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are essentially four kinds of cells in your Jupyter notebook: Code Cells, Markdown Cells, Raw Cells, and Header Cells, though there are six levels of Header Cells.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Code Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, Jupyter Notebooks' Code Cells will execute Python. Jupyter Notebooks generally also support JavaScript, Python, HTML, and Bash commands. For a more comprehensive list, see your Kernel's documentation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.1 Code Cell Layout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code cells have both an input and an output component. You can view these components in three different ways. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.1.1 Row Configuration (Default Setting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unless you specific otherwise, your Code Cells will always be configured this way, with both the input and output components appearing as horizontal rows and with the input above the output. Below is an example of a Code Cell in this default setting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "format": "row"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.1.2 Cell Tabbing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cell tabbing allows you to look at the input and output components of a cell separately. It also allows you to hide either component behind the other, which can be usefull when creating visualizations of data. Below is an example of a tabbed Code Cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "format": "tab"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.1.3 Column Configuration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the row configuration, the column layout option allows you to look at both the input and the output components at once. In the column layout, however, the two components appear beside one another, with the input on the left and the output on the right. Below is an example of a Code Cell in the column configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "format": "column"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Markdown Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Jupyter Notebooks, Markdown Cells are the easiest way to write and format text. For a more thorough explanation of how to write in Markdown cells, refer to [this section of the guide][writing markdown].\n",
    "\n",
    "[writing markdown]: #4.-Using-Markdown-Cells-for-Writing \"Using Markdown Cells for Writing\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Raw Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Raw Cells, unlike all other Jupyter Notebook cells, have no input-output distinction. This means that Raw Cells cannot be rendered into anything other than what they already are. If you click the run button in your tool bar with a Raw Cell selected, the cell will remain exactly as is and your Jupyter Notebook will automatically select the cell directly below it. Raw cells have no style options, just the same monospace font that you use in all other unrendered Notebook cells. You cannot bold, italicize, or enlarge any text or characters in a Raw Cell. \n",
    "\n",
    "Because they have no rendered form, Raw Cells are mainly used to create examples. If you save and close your Notebook and then reopen it, all of the Code, Markdown, and Header Cells will automatically render in whatever form you left them when you first closed the document. This means  that if you wanted to preserve the unrendered version of a cell, say if you were writing a computer science paper and needed code examples, or if you were writing [documentation on how to use Markdown] [writing markdown] and needed to demonstrate what input would yield which output, then you might want to use a Raw Cell to make sure your examples stayed in their most useful form. \n",
    "\n",
    "[writing markdown]: #4.-Using-Markdown-Cells-for-Writing \"Using Markdown Cells for Writing\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Header Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While it is possible to organize your document using [Markdown headers][], Header Cells provide a more deeply structural organization for your Notebook and thus there are several advantages to using them. \n",
    "\n",
    "[Markdown headers]: #4.1.3-Headers \"Headers\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 Linking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Header Cells have specific locations inside your Notebook. This means you can use them to [create Notebook-internal links](#4.3.5-Notebook-Internal-Links \"Notebook-Internal Links\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 Automatic Section Numbering and Table of Contents Support"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your Jupyter Notebook has two helpful tools that utilize the structural organization that Header Cells give your document: automatic section numbering and table of contents generation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2.1 Automatic Section Numbering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose you are writing a paper and, as is prone to happening when you have a lot of complicate thoughts buzzing around your brain, you've reorganized your ideas several times. Automatic section numbering will go through your Notebook and number your sections and subsection as designated by your Header Cells. This means that if you've moved one or more big sections around several times, you won't have to go through your paper and renumber it, as well as all its subsections, yourself.\n",
    "\n",
    "\n",
    "\n",
    "**Notes:** Automatic Section Numbering tri-toggling tool, so when you click the Number Sections button one of three actions will occur: Automatic Section Numbering will number your sections, correct inconsistent numbering, or unnumber your sections (if all of your sections are already consistently and correctly numbered). \n",
    "\n",
    "So, even if you have previously numbered your sections, Automatic Section Numbering will go through your document, delete the current section numbers, and replace them the correct number in a linear sequence. This means that if your third section was once your second, Automatic Section Numbering will delete the \"2\" in front of your section's name and replace it with a \"3.\" \n",
    "\n",
    "While this function saves you a lot of time, it creates one limitation. Maybe you're writing a paper about children's books and one of the books you're discussing is called **`2 Cats`**. You've unsurprisingly titled the section where you summarize and analyze this book **`2 Cats`**. Automatic Section Numbering will assume the number 2 is section information and delete it, leaving just the title **`Cats`** behind. If you bold, italicize, or place the title of the section inside quotes, however, the entire section title will be be preserved without any trouble. It should also be noted that even if you must title a section with a number occurring before any letters and you do not want to bold it, italicize it, or place it inside quotes, then you can always run Automatic Section Numbering and then go to that section and retype its name by hand. \n",
    "\n",
    "Because Automatic Section Numbering uses your header cells, its performance relies somewhat on the clarity of your organization. If you have two sections that begin with Header 1 Cells in your paper, and each of the sections has two subsections that begin with Header 2 Cells, Automatic Section Numbering will number them 1, 1.1, 1.2, 2, 2.1, and 2.2 respectively. If, however, you have used a Header 3 Cell to indicate the beginning of what would have been section 2.1, Automatic Section Numbering will number that section 2.0.1 and an error message will appear telling you that \"You placed a Header 3 cell under a Header 2 Cell in section 2\". Similarly, if you begin your paper with any Header Cell smaller than a Header 1, say a Header 3 Cell, then Automatic Section Numbering will number your first section 0.0.3 and an error message will appear telling you that \"Notebook begins with a Header 3 Cell.\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2.2 Table of Contents Support"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Table of Contents tool will automatically generate a table of contents for your paper by taking all your Header Cell titles and ordering them in a list, which it will place in a new cell at the very beginning of you Notebook. Because your Notebook does note utilize formal page breaks or numbers, each listed section will be hyperlinked to the actual section within your document.\n",
    "\n",
    "**Notes: **Because Table of Contents Support uses your header cells, its performance relies somewhat on the clarity of your organization. If you have two sections that begin with Header 1 Cells in your paper, and each of the sections has two subsections that begin with Header 2 Cells, Table of Contents will order them in the following way:\n",
    "\n",
    "* 1.\n",
    "   * 1.1\n",
    "   * 1.2\n",
    "* 2.\n",
    "   * 2.1\n",
    "   * 2.2\n",
    "    \n",
    "\n",
    "If, however, you have used a Header 3 Cell to indicate the beginning of what would have been section 2.1, Table of Contents Support will insert a dummy line so that your table of contents looks like this:\n",
    "\n",
    "\n",
    "* 1.\n",
    "   * 1.1\n",
    "   * 1.2\n",
    "* 2.\n",
    "   * &nbsp;           \n",
    "       * 2.0.1\n",
    "   * 2.2\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2.3 Using Both Automatic Section Numbering and Table of Contents Support"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Automatic Section Numbering will always update every aspect of your notebook that is dependent on the title of one or more of your sections. This means that it will automatically correct an existing table of contents and all of your Notebook-internal links to reflect the new numbered section titles.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Keyboard Shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter Notebooks support many helpful Keyboard shortcuts, including ones for most of the buttons in [your toolbar][]. To view these shortcuts, you can click the help menu and then select Keyboard Shortcuts, as pictured below. \n",
    "\n",
    "![](./assets/keyboardshortcuts.png)\n",
    "[your toolbar]: #1.-Getting-to-Know-your-Jupyter-Notebook's-Toolbar \"Getting to know Your Jupyter Notebook's Toolbar\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/keyboardshortcuts.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Using Markdown Cells for Writing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why aren't there font and font size selection drop down menus, buttons I can press to bold and italicize my text, or other advanced style options in my Notebook?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use Microsoft Word, Google Docs, Apple Pages, Open Office, or any other word processing software, you generally use your mouse to select various style options, like line spacing, font size, font color, paragraph format etc. This kind of system is often describes as a WYSIWYG (What You See Is What You Get) interface. This means that the input (what you tell the computer) exactly matches the output (what the computer gives back to you). If you type the letter **`G`**, highlight it, select the color green and up the font size to 64 pt, your word processor will show you a fairly large green colored letter **`G`**. And if you print out that document you will print out a fairly large green colored letter **`G`**. \n",
    "\n",
    "This Notebook, however, does not use a WYSIWYG interface. Instead it uses something called a \"[markup Language][]\". When you use a a markup language, your input does not necessarily exactly equal your output.\n",
    "\n",
    "\n",
    "[markup language]: http://en.wikipedia.org/wiki/Markup_language \"Wikipedia Article on Markup\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, if I type \"#Header 1\" at the beginning of a cell, but then press Shift-Enter (or click the play button at the top of the window), this notebook will turn my input into a somewhat different output in the following way:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "#Header 1\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Header 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if I type \"##Header 2\" (at the beginning of a cell), this notebook will turn that input into another output:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "##Header 2\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Header 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In these examples, the hashtags are markers which tell the Notebook how to typeset the text. There are many markup languages, but one family, or perhaps guiding philosophy, of markup languages is called \"Markdown,\" named somewhat jokingly for its simplicity. Your Notebook uses \"marked,\" a Markdown library of typeset and other formatting instructions, like the hashtags in the examples above.\n",
    "\n",
    "Markdown is a markup language that generates HTML, which the cell can interpret and render. This means that Markdown Cells can also render plain HTML code. If you're interested in learning HTML, check out this [helpful online tutorial][html tutorial].\n",
    "\n",
    "[html tutorial]: http://www.w3schools.com/html/ \"w3schools.com HTML Tutorial\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why Use Markdown (and not a WYSIWYG)?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why is Markdown better? Well, it’s worth saying that maybe it isn't. Mainly, it’s not actually a question of better or worse, but of what’s in front of you and of who you are. A definitive answer depends on the user and on that user’s goals and experience. These Notebooks don't use Markdown because it's definitely better, but rather because it's different and thus encourages users to think about their work differently. \n",
    "\n",
    "It is very important for computer science students to learn how to conceptualize input and output as dependent, but also distinct. One good reason to use Markdown is that it encourages this kind of thinking. Relatedly, it might also promote focus on substance over surface aesthetic. Markdown is somewhat limited in its style options, which means that there are inherently fewer non-subject-specific concerns to agonize over while working. It is the conceit of this philosophy that you would, by using Markdown and this Notebook, begin to think of the specific stylistic rendering of your cells as distinct from what you type into those same cells, and thus also think of the content of your writing as necessarily separate from its formating and appearance. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Block Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.1 Paragraph Breaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Paragraphs consist of one or more consecutive lines of text and they are separated by one or more blank lines. If a line contains only spaces, it is a blank line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.2 Line Breaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.2.1 Hard-Wrapping and Soft-Wrapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're used to word processing software, you've been writing with automatically hard-wrapped lines and paragraphs. In a hard-wrapped paragraph the line breaks are not dependent on the size of the viewing window. If you click and drag your mouse to expand a word processing document, for example, the shape of the paragraphs and the length of the lines will not change. In other words, the length of a hard-wrapped line is determined either by the number of words in the line (in the case of word processing software where this number is predetermined and the program wraps for the user automatically), or individual intention (when a user manually presses an Enter or Return key to control exactly how long a line is).\n",
    "\n",
    "Soft-wrapped paragraphs and lines, however, *do* depend on the size of their viewing window. If you increase the size of a window where soft-wrapped paragraphs are displayed, they too will expand into longer lines, becoming shorter and wider to fill the increased window space horizontally. Unsurprising, then, if you *narrow* a window, soft-wrapped lines will shrink and the paragraphs will become longer vertically. \n",
    "\n",
    "Markdown, unlike most word processing software, does not automatically hard-wrap. If you want your paragraphs to have a particular or deliberate shape and size, you must insert your own break by ending the line with two spaces and then typing Return.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.2.2 Soft-Wrapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tt>\n",
    "blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah\n",
    "</tt>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.2.3 Hard-Wrapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tt>\n",
    "blah blah blah blah blah  \n",
    "blah blah blah blah blah blah blah blah blah  \n",
    "blah blah blah blah blah blah blah blah blah blah blah  \n",
    "blah blah blah blah blah  \n",
    "blah blah blah blah blah   \n",
    "blah blah blah blah blah blah blah blah blah blah blah blah blah  \n",
    "</tt>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "blah blah blah blah blah  \n",
    "blah blah blah blah blah blah blah blah blah  \n",
    "blah blah blah blah blah blah blah blah blah blah blah  \n",
    "blah blah blah blah blah  \n",
    "blah blah blah blah blah   \n",
    "blah blah blah blah blah blah blah blah blah blah blah blah blah  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.3 Headers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "#Header 1\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Header 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "##Header 2\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Header 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "###Header 3\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Header 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "####Header 4\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Header 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "#####Header 5\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Header 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "######Header 6\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Header 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.4 Block Quotes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.4.1 Standard Block Quoting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tt>\n",
    ">blah blah block quote blah blah block quote blah blah block  \n",
    "quote blah blah block quote blah blah block   \n",
    "quote blah blah block quote blah blah block quote blah blah block quote\n",
    "</tt>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">blah blah block quote blah blah block quote blah blah block  \n",
    "quote blah blah block quote blah blah block   \n",
    "quote blah blah block quote blah blah block quote blah blah block quote"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: Block quotes work best if you intentionally hard-wrap the lines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.4.2 Nested Block Quoting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    ">blah blah block quote blah blah block quote blah blah block  \n",
    "block quote blah blah block block quote blah blah block  \n",
    ">>quote blah blah block quote blah blah  \n",
    "block block quote blah blah block   \n",
    ">>>quote blah blah block quote blah blah block quote blah blah block quote\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">blah blah block quote blah blah block quote blah blah block  \n",
    "block quote blah blah block block quote blah blah block  \n",
    ">>quote blah blah block quote blah blah  \n",
    "block block quote blah blah block   \n",
    ">>>quote blah blah block quote blah blah block quote blah blah block quote"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.5 Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.5.1 Ordered Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Markdown, you can list items using numbers, a **`+`**, a **` - `**, or a **`*`**. However, if the first item in a list or sublist is numbered, Markdown will interpret the entire list as ordered and will automatically number the items linearly, no matter what character you use to denote any given separate item."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "####Groceries:\n",
    "\n",
    "0. Fruit:\n",
    "    6. Pears\n",
    "    0. Peaches\n",
    "    3. Plums\n",
    "    4. Apples \n",
    "        2. Granny Smith \n",
    "        7. Gala\n",
    "    * Oranges\n",
    "    - Berries \n",
    "        8. Strawberries \n",
    "        + Blueberries\n",
    "        * Raspberries\n",
    "    - Bananas\n",
    "9. Bread:\n",
    "    9. Whole Wheat\n",
    "        0. With oats on crust\n",
    "        0. Without oats on crust\n",
    "    0. Rye \n",
    "    0. White\n",
    "0. Dairy:\n",
    "    0. Milk\n",
    "        0. Whole\n",
    "        0. Skim\n",
    "    0. Cheese\n",
    "        0. Wisconsin Cheddar\n",
    "        0. Pepper Jack\n",
    "</pre> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Groceries:\n",
    "\n",
    "0. Fruit:\n",
    "    6. Pears\n",
    "    0. Peaches\n",
    "    3. Plums\n",
    "    4. Apples \n",
    "        2. Granny Smith \n",
    "        7. Gala\n",
    "    * Oranges\n",
    "    - Berries \n",
    "        8. Strawberries \n",
    "        + Blueberries\n",
    "        * Raspberries\n",
    "    - Bananas\n",
    "9. Bread:\n",
    "    9. Whole Wheat\n",
    "        0. With oats on crust\n",
    "        0. Without oats on crust\n",
    "    0. Rye \n",
    "    0. White\n",
    "0. Dairy:\n",
    "    0. Milk\n",
    "        0. Whole\n",
    "        0. Skim\n",
    "    0. Cheese\n",
    "        0. Wisconsin Cheddar\n",
    "        0. Pepper Jack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.5.2 Bulleted Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you begin your list or sublist with a **`+`**, a **` - `**, or a **`*`**, then Markdown will interpret the whole list as unordered and will use bullets regardless of the characters you type before any individual list item."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "####Groceries:\n",
    "\n",
    "* Fruit:\n",
    "    * Pears\n",
    "    0. Peaches\n",
    "    3. Plums\n",
    "    4. Apples \n",
    "        - Granny Smith \n",
    "        7. Gala\n",
    "    * Oranges\n",
    "    - Berries \n",
    "        - Strawberries \n",
    "        + Blueberries\n",
    "        * Raspberries\n",
    "    - Bananas\n",
    "9. Bread:\n",
    "    * Whole Wheat\n",
    "        * With oats on crust\n",
    "        0. Without oats on crust\n",
    "    + Rye \n",
    "    0. White\n",
    "0. Dairy:\n",
    "    * Milk\n",
    "        + Whole\n",
    "        0. Skim\n",
    "    - Cheese\n",
    "        - Wisconsin Cheddar\n",
    "        0. Pepper Jack\n",
    "        </pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Groceries:\n",
    "\n",
    "* Fruit:\n",
    "    * Pears\n",
    "    0. Peaches\n",
    "    3. Plums\n",
    "    4. Apples \n",
    "        - Granny Smith \n",
    "        7. Gala\n",
    "    * Oranges\n",
    "    - Berries \n",
    "        - Strawberries \n",
    "        + Blueberries\n",
    "        * Raspberries\n",
    "    - Bananas\n",
    "9. Bread:\n",
    "    * Whole Wheat\n",
    "        * With oats on crust\n",
    "        0. Without oats on crust\n",
    "    + Rye \n",
    "    0. White\n",
    "0. Dairy:\n",
    "    * Milk\n",
    "        + Whole\n",
    "        0. Skim\n",
    "    - Cheese\n",
    "        - Wisconsin Cheddar\n",
    "        0. Pepper Jack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.6 Section Breaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "___\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "***\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>------</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "* * *\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* * *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "_ _ _\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_ _ _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre> \n",
    "- - -\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- - -"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 Backslash Escape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you want to include a literal character, like a **`#`**, that usually has a specific function in Markdown? Backslash Escape is a function that prevents Markdown from interpreting a character as an instruction, rather than as the character itself. It works like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "\\# Wow, this isn't a header. \n",
    "# This is definitely a header.\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\# Wow, this isn't a header. \n",
    "# This is definitely a header."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Markdown allows you to use a backslash to escape from the functions of the following characters:\n",
    "* \\   backslash\n",
    "* `   backtick\n",
    "* \\*   asterisk\n",
    "* _   underscore\n",
    "* {}  curly braces\n",
    "* []  square brackets\n",
    "* ()  parentheses\n",
    "* \\#   hashtag\n",
    "* \\+   plus sign|\n",
    "* \\-   minus sign (hyphen)\n",
    "* .   dot\n",
    "* !   exclamation mark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 Hyperlinks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.1 Automatic Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "http://en.wikipedia.org\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://en.wikipedia.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.2 Standard Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "[click this link](http://en.wikipedia.org)\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[click this link](http://en.wikipedia.org)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.3 Standard Links With Mouse-Over Titles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre> \n",
    "[click this link](http://en.wikipedia.org \"Wikipedia\")\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[click this link](http://en.wikipedia.org \"Wikipedia\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.4 Reference Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose you are writing a document in which you intend to include many links. The format above is a little arduous and if you have to do it repeatedly *while* you're trying to focus on the content of what you're writing, it's going to be a really big pain. \n",
    "\n",
    "Fortunately, there is an alternative way to insert hyperlinks into your text, one where you indicate that there is a link, name that link, and then use the name to provide the actually URL later on when you're less in the writing zone. This method can be thought of as a \"reference-style\" link because it is similar to using in-text citations and then defining those citations later in a more detailed reference section or bibliography. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "This is [a reference] [identification tag for link]\n",
    "\n",
    "[identification tag for link]: http://en.wikipedia.org/wiki/Chile \"Wikipedia Article About Chile\"\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is [a reference] [identification tag for link]\n",
    "\n",
    "[identification tag for link]: http://en.wikipedia.org/wiki/Chile \"Wikipedia Article About Chile\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** The \"identification tag for link\" can be anything. For example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "This is [a reference] [lfskdhflhslgfh333676]\n",
    "\n",
    "[lfskdhflhslgfh333676]: http://en.wikipedia.org/wiki/Chile \"Wikipedia Article About Chile\"\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is [a reference] [lfskdhflhslgfh333676]\n",
    "\n",
    "[lfskdhflhslgfh333676]: http://en.wikipedia.org/wiki/Chile \"Wikipedia Article About Chile\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means you can give your link an intuitive, easy to remember, and relevant ID:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "This is [a reference][Chile]\n",
    "\n",
    "[chile]: http://en.wikipedia.org/wiki/Chile \"Wikipedia Article About Chile\"\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is [a reference][Chile]\n",
    "\n",
    "[chile]: http://en.wikipedia.org/wiki/Chile \"Wikipedia Article About Chile\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: Link IDs are not case-sensitive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't want to give your link an ID, you don't have to. As a short cut, Markdown will understand if you just use the words in the first set of brackets to define the link later on. This works in the following way:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "This is [a reference] about MRI\n",
    "\n",
    "[a reference]:https://en.wikipedia.org/wiki/Magnetic_resonance_imaging \"Wikipedia Article About MRI\"\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is [a reference][] about MRI\n",
    "\n",
    "[a reference]:https://en.wikipedia.org/wiki/Magnetic_resonance_imaging \"Wikipedia Article About MRI\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another really helpful feature of a reference-style link is that you can define the link anywhere in the cell. (must be in the cell) For example:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Medical imaging [ref1] is the technique and process of creating visual representations of the interior of a body for clinical analysis and medical intervention, as well as visual representation of the function of some organs or tissues (physiology [ref2]). Medical imaging seeks to reveal internal structures hidden by the skin and bones, as well as to diagnose and treat disease. Medical imaging also establishes a database of normal anatomy and physiology to make it possible to identify abnormalities. Although imaging of removed organs and tissues can be performed for medical reasons, such procedures are usually considered part of pathology instead of medical imaging.<br> \n",
    "\n",
    "\n",
    "**References**\n",
    "\n",
    "[ref1]: https://en.wikipedia.org/wiki/Medical_imaging \"Wikipedia Article About Medical imaging\"<br>\n",
    "[ref2]: https://en.wikipedia.org/wiki/Physiology \"Wikipedia Article About Physiology\"  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a reference [ref] \n",
    "\n",
    "[ref]: https://en.wikipedia.org/wiki/Medical_imaging \"Wikipedia Article About Medical imaging\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Providing a mouse-over title for any link, regardless of whether it is a standard or reference-stlye type, is optional. With reference-style links, you can include the mouse-over title by placing it in quotes, single quotes, or parentheses. For standard links, you can only define a mouse-over title in quotes.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.5 Notebook-Internal Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you create a Header you also create a discrete location within your Notebook. This means that, just like you can link to a specific location on the web, you can also link to a Header Cell inside your Notebook. Internal links have very similar Markdown formatting to regular links. The only difference is that the name of the link, which is the URL in the case of external links, is just a hashtag plus the name of the Header Cell you are linking to (case-sensitive) with dashes in between every word. If you hover your mouse over a Header Cell, a blue Greek pi letter will appear next to your title. If you click on it, the URL at the top of your window will change and the internal link to that section will appear last in the address. You can copy and paste it in order to make an internal link inside a Markdown Cell.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.5.1 Standard Notebook-Internal Links Without Mouse-Over Titles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "&#91;Here's a link to the section of Automatic Section Numbering](&#35;Automatic-Section-Numbering)\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Here's a link to the section of Automatic Section Numbering](#2.4.2.1-Automatic-Section-Numbering)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.5.2 Standard Notebook-Internal Links With Mouse-Over Titles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "&#91;Here's a link to the section on lists](#Lists \"Lists\")\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Here's a link to the section of Automatic Section Numbering](#2.4.2.1-Automatic-Section-Numbering)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.5.3 Reference-Style Notebook-Internal Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "[Here's a link to the section on Table of Contents Support][TOC]\n",
    "\n",
    "&#91;TOC]: #Table-of-Contents-Support\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Here's a link to the section on Table of Contents Support][TOC]\n",
    "\n",
    "[TOC]: #2.4.2.2-Table-of-Contents-Support"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 Tables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Markdown, you can make a table by using vertical bars and dashes to define the cell and header borders:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "|Header|Header|Header|Header|\n",
    "|------|------|------|------|\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Header|Header|Header|Header|\n",
    "|------|------|------|------|\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "|Cell  |Cell  |Cell  | Cell |\n",
    "|Cell  |Cell  |Cell  | Cell |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Making a table this way might be especially useful if you want your document to be legible both rendered and unrendered. However, you don't *need* to include all of those dashes, vertical bars, and spaces for Markdown to understand that you're making a table. Here's the bare minimum you would need to create the table above:  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "Header|Header|Header|Header\n",
    "-|-|-|-\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Header|Header|Header|Header\n",
    "-|-|-|-\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n",
    "Cell|Cell|Cell|Cell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to note that the second line of dashes and vertical bars is essential. If you have just the line of headers and the second line of dashes and vertical bars, that's enough for Markdown to make a table. \n",
    "\n",
    "Another important formatting issue has to do with the vertical bars that define the left and right edges of the table. If you include all the vertical bars on the far left and right of the table, like in the first example above, Markdown will ignore them completely. *But*, if you leave out some and include others, Markdown will interpret any extra vertical bar as an additional cell on the side that the bar appears in the unrendered version of the text. This also means that if you include the far left or right vertical bar in the second line of bars and dashes, you must include all of the otherwise optional vertical bars (like in the first example above)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4.1 Cell Justification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If not otherwise specified the text in each header and cell of a table will justify to the left. If, however, you wish to specify either right justification or centering, you may do so like this: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tt>\n",
    "**Centered, Right-Justified, and Regular Cells and Headers**:\n",
    "\n",
    "centered header  |  regular header  |  right-justified header  |  centered header  |  regular header  \n",
    ":-:|-|-:|:-:|-\n",
    "centered cell|regular cell|right-justified cell|centered cell|regular cell\n",
    "centered cell|regular cell|right-justified cell|centered cell|regular cell\n",
    "</tt>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Centered, Right-Justified, and Regular Cells and Headers**:\n",
    "\n",
    "centered header  |  regular header  |  right-justified header  |  centered header  |  regular header  \n",
    ":-:|-|-:|:-:|-\n",
    "centered cell|regular cell|right-justified cell|centered cell|regular cell\n",
    "centered cell|regular cell|right-justified cell|centered cell|regular cell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While it is difficult to see that the headers are differently justified from one another, this is just because the longest line of characters in any column defines the width of the headers and cells in that column. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** You cannot make tables directly beneath a line of text. You must put a blank line between the end of a paragraph and the beginning of a table. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.5 Style and Emphasis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "*Italics*\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Italics*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "_Italics_\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Italics_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "**Bold**\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bold**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "__Bold__\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Bold__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** If you want actual asterisks or underscores to appear in your text, you can use the [backslash escape function] [backslash] like this:\n",
    "\n",
    "[backslash]: #4.2-Backslash-Escape \"Backslash Escape\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "\\*awesome asterisks\\* and \\_incredible under scores\\_\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\*awesome asterisks\\* and \\_incredible under scores\\_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.6 Other Characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre> \n",
    "Ampersand &amp;amp; Ampersand\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ampersand &amp; Ampersand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "&amp;lt; angle brackets &amp;gt;\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&lt; angle brackets &gt;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "&amp;quot; quotes &amp;quot; "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&quot; quotes &quot; "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.7 Including Code Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to signify that a particular section of text is actually an example of code, you can use backquotes to surround the code example. These will switch the font to monospace, which creates a clear visual formatting difference between the text that is meant to be code and the text that isn't. \n",
    "\n",
    "Code can either in the middle of a paragraph, or as a block. Use a single backquote to start and stop code in the middle of a paragraph. Here's an example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "The word `monospace` will appear in a code-like form.\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The word `monospace` will appear in a code-like form."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** If you want to include a literal backquote in your code example you must suround the whole text block in double backquotes like this: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "`` Look at this literal backquote ` ``\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`` Look at this literal backquote ` ``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To include a complete code-block inside a Markdown cell, use triple backquotes. Optionally, you can put the name of the language that you are quoting after the starting triple backquotes, like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "```python\n",
    "def function(n):\n",
    "    return n + 1\n",
    "```\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That will format the code-block (sometimes called \"fenced code\") with syntax coloring. The above code block will be rendered like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def function(n):\n",
    "    return n + 1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The language formatting names that you can currently use after the triple backquote are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "apl           django   go            jinja2      ntriples    q       smalltalk    toml\n",
    "asterisk      dtd      groovy        julia       octave      r       smarty       turtle\n",
    "clike         dylan    haml          less        pascal      rpm     smartymixed  vb\n",
    "clojure       ecl      haskell       livescript  pegjs       rst     solr         vbscript\n",
    "cobol         eiffel   haxe          lua         perl        ruby    sparql       velocity\n",
    "coffeescript  erlang   htmlembedded  markdown    php         rust    sql          verilog\n",
    "commonlisp    fortran  htmlmixed                 pig         sass    stex         xml\n",
    "css           gas      http          mirc        properties  scheme  tcl          xquery\n",
    "d             gfm      jade          mllike      puppet      shell   tiddlywiki   yaml\n",
    "diff          gherkin  javascript    nginx       python      sieve   tiki         z80\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.8 Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.8.1 Images from the Internet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inserting an image from the internet is almost identical to inserting a link. You just also type a **`!`** before the first set of brackets:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "![It doesn't matter what you write here](https://upload.wikimedia.org/wikipedia/commons/3/35/113abcd_Medical_Imaging_Techniques.jpg \"Medical imaging\")\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![It doesn't matter what you write here](https://upload.wikimedia.org/wikipedia/commons/3/35/113abcd_Medical_Imaging_Techniques.jpg \"Medical imaging\")\n",
    "\n",
    "(a) The results of a CT scan of the head are shown as successive transverse sections. (b) An MRI machine generates a magnetic field around a patient. (c) PET scans use radiopharmaceuticals to create images of active blood flow and physiologic activity of the organ or organs being targeted. (d) Ultrasound technology is used to monitor pregnancies because it is the least invasive of imaging techniques and uses no electromagnetic radiation [https://arxiv.org/abs/1401.0166]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Unlike with a link, the words that you type in the first set of brackets do not appear when they are rendered into html by Markdown. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.1.1 Reference-Style Images from the Internet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like with links, you can also use a reference-style format when inserting images from the internet. This involves indicating where you want to place a picture, giving that picture an ID tag, and then later defining that ID tag. The process is nearly identical to using the reference-style format to insert a link:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "Multispektral MRI: ![][MRI]\n",
    "\n",
    "[MRI]:https://upload.wikimedia.org/wikipedia/commons/0/03/T1t2PD.jpg \"MRI\"\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multispektral MRI: ![][MRI]\n",
    "\n",
    "[MRI]:https://upload.wikimedia.org/wikipedia/commons/0/03/T1t2PD.jpg \"MRI\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.9 LaTeX Math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter Notebooks' Markdown cells support LateX for formatting mathematical equations. To tell Markdown to interpret your text as LaTex, surround your input with dollar signs like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "$z=\\dfrac{2x}{3y}$\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$z=\\dfrac{2x}{3y}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An equation can be very complex:\n",
    "\n",
    "<pre>\n",
    "$F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want your LaTex equations to be indented towards the center of the cell, surround your input with two dollar signs on each side like this: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "$$2x+3y=z$$\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$2x+3y=z$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a comprehensive guide to the mathematical symbols and notations supported by Jupyter Notebooks' Markdown cells, check out [Martin Keefe's helpful reference materials on the subject][mkeefe].\n",
    "\n",
    "[mkeefe]: http://martinkeefe.com/math/mathjax1 \"Martin Keefe's MathJax Guide\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Bibliographic Support"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bibliographic Support makes managing references and citations in your Notebook much easier, by automating some of the bibliographic process every person goes through when doing research or writing in an academic context. There are essentially three steps to this process for which your Notebook's Bibliographic support can assist: gathering and organizing sources you intend to use, citing those sources within the text you are writing, and compiling all of the material you referenced in an organized, correctly formatted list, the kind which usually appears at the end of a paper in a section titled \"References,\" \"Bibliography,\" or \"Works Cited. \n",
    "\n",
    "In order to benefit from this functionality, you need to do two things while writing your paper: first, you need to create a [Bibtex database][bibdb] of information about your sources and second, you must use the the [cite command][cc] in your Markdown writing cells to indicate where you want in-text citations to appear.\n",
    "\n",
    "If you do both these things, the \"Generate References\" button will be able to do its job by replacing all of your cite commands with validly formatted in-text citations and creating a References section at the end of your document, which will only ever include the works you specifically cited within in your Notebook. \n",
    "\n",
    "**Note:** References are generated without a header cell, just a [markdown header][]. This means that if you want a References section to appear in your table of contents, you will have to unrender the References cell, delete the \"References\" header, make a Header Cell of the appropriate level and title it \"References\" yourself, and then generate a table of contents using [Table of Contents Support][table of contents]. This way, you can also title your References section \"Bibliography\" or \"Works Cited,\" if you want.\n",
    "\n",
    "[markdown header]: #4.1.3-Headers\n",
    "[table of contents]: #2.4.2.2-Table-of-Contents-Support\n",
    "[bibdb]: #5.1-Creating-a-Bibtex-Database\n",
    "[cc]:#5.2-Cite-Commands-and-Citation-IDs\n",
    "\n",
    "See also https://stackoverflow.com/questions/30061902/how-to-handle-citations-in-ipython-notebook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 Creating a Bibtex Database"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bibtex is reference management software for formatting lists of references ([from Wikipedia](BibTeX is reference management software for formatting lists of references \"Wikipedia Article On Bibtex\")). While your Notebook does not use the Bibtex software, it does use [Bibtex formatting](#5.1.3-Formatting-Bibtex-Entries) for creating references within your Bibliographic database.\n",
    "\n",
    "In order for the Generate References button to work, you need a bibliographic database for it to search and match up with the sources you've indicated you want to credit using [cite commands and citation IDs](#5.2-Cite-Commands-and-Citation-IDs).\n",
    "\n",
    "When creating a bibliographic database for your Notebook, you have two options: you can make an external database, which will exist in a separate Notebook from the one you are writing in, or you can make an internal database which will exist in a single cell inside the Notebook in which you are writing. Below are explanations of how to use these database creation strategies, as well as a discussion of the pros and cons for each. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.1 External Bibliographic Databases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create an external bibliographic database, you will need to create a new Notebook and title it **`Bibliography`** in the toplevel folder of your current Jupyter session. As long as you do not also have an internal bibliographic database, when you click the Generate References button your Notebook's Bibliographic Support will search this other **`Bibliography`** Notebook for Bibtex entries. Bibtex entries can be in any cell and in any kind of cell in your **`Bibliography`** Notebook as long as the cell begins with **`<!--bibtex`** and ends with **`-->`**. Go to [this section][bibfor] for examples of valid BibTex formatting.\n",
    "\n",
    "Not every cell has to contain BibTex entries for the external bibliographic database to work as intended with your Notebook's bibliographic support. This means you can use the same helpful organization features that you use in other Notebooks, like [Automatic Section Numbering][asn] and [Table of Contents Support][toc], to structure your own little library of references. The best part of this is that any Notebook containing validly formatted [cite commands][cc] can check your external database and find only the items that you have indicated you want to cite. So you only ever have to make the entry once and your external database can grow large and comprehensive over the course of your accademic writing career. \n",
    "\n",
    "There are several advantages to using an external database over [an internal one][internal database]. The biggest one, which has already been described, is that you will only ever need to create one and you can organize it into sections by using headers and generating [automatic section numbers][asn] and a [table of contents][toc]. These tools will help you to easily find the right [citation ID][cc] for a given source you want to cite. The other major advantage is that an external database is not visible when viewing the Notebook in which you are citing sources and generating a References list. Bibtex databases are not very attractive or readable and you probably won't want one to show up in your finished document. There are [ways to hide internal databases][hiding bibtex cell], but it's convenient not to have to worry about that. \n",
    "\n",
    "\n",
    "[asn]: #2.4.2.1-Automatic-Section-Numbering\n",
    "[toc]: #2.4.2.2-Table-of-Contents-Support\n",
    "[cc]: #5.2-Cite-Commands-and-Citation-IDs\n",
    "[hiding bibtex cell]: #5.1.2.1-Hiding-Your-Internal-Database\n",
    "[bibfor]:#5.1.3-Formatting-Bibtex-Entries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.2 Internal Bibliographic Databases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike [external bibliographic databases][exd], which are comprised from an entire separate notebook, internal bibliographic databases consist of only one cell within in the Notebook in which you are citing sources and compiling a References list. The single cell, like all of the many BibTex cells that can make up an external database, must begin with **`<!--bibtex`** and end with **`-->`** in order to be validly formatted and correctly interpreted by your Notebook's Bibliographic Support. It's probably best to keep this cell at the very end or the very beginning of your Notebook so you always know where it is. This is because when you use an intenral bibliographic databse it can only consist of one cell. This means that if you want to cite multiple sources you will need to keep track of the single cell that comprises your entire internal bibliographic database during every step of the research and writing process. \n",
    "\n",
    "Internal bibliographic databases make more sense when your project is a small one and the list of total sources is short. This is especially convenient if you don't already have a built-up external database. With an internal database you don't have to create and organize a whole separate Notebook, a task that's only useful when you have to keep track of a lot of different material.  Additionally, if you want to share your finished Notebook with others in a form that retains its structural validity, you only have to send one Notebook, as oppose to both the project itself and the Notebook that comprises your external bibliographic database. This is especially useful for a group project, where you want to give another reader the ability to edit, not simply read, your References section. \n",
    "\n",
    "[exd]:#5.1.1-External-Bibliographic-Databases\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.2.1 Hiding Your Internal Database"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though they have some advantages, especially for smaller projects, internal databases have on major draw back. They are not very attractive or polished looking and you probably won't want one to appear in your final product. Fortunately, there are two methods for hiding your internal biblioraphic database.\n",
    "\n",
    "While your Notebook's bibliographic support will be able to interpret [correctly formatted BibTex entries][bibfor] in any [kind of cell][cell kind], if you use a [Markdown Cell][md cell] to store your internal bibliographic database, then when you run the cell all of the ugly BibTex formatting will disappear. This is handy, but it also makes the cell very difficult to find, so remember to keep careful track of where your hidden BibTex databse is if you're planning to edit it later. If you want your final product to be viewed stably as HTML, then you can make your internal BibTex database inside a [Raw Cell][RC], use the [cell toolbar][] to select \"Raw Cell Format\", and then select \"None\" in the toolbar that appears in the corner of your Raw Cell BibTex database. This way, you will still be able to easily find and edit the database when you are working on your Notebook, but others won't be able to see the database when viewing your project in its final form. \n",
    "\n",
    "\n",
    "[cell toolbar]: #1.-Getting-to-Know-your-Jupyter-Notebook's-Toolbar\n",
    "[bibfor]:#5.1.3-Formatting-Bibtex-Entries\n",
    "[RC]:#2.3-Raw-Cells\n",
    "[md cell]: #2.2-Markdown-Cells\n",
    "[cell kind]: #2.-Different-Kinds-of-Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1.3 Formatting Bibtex Entries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "BibTex entries consist of three crucial components: one, the type of source you are citing (a book, article, website, etc.); two, the unique [citation ID][cc] you wish to remember the source by; and three, the fields of information about that source (author, title of work, date of publication, etc.). Below is an example entry, with each of these three components designated clearly\n",
    "\n",
    "<pre>\n",
    "\n",
    "&lt;!--bibtex\n",
    "\n",
    "@ENTRY TYPE{CITATION ID,\n",
    "    FIELD 1 = {source specific information},\n",
    "    FIELD 2 = {source specific informatio},\n",
    "    FIEL 3 = {source specific informatio},\n",
    "    FIELD 4 = {source specific informatio}\n",
    "}\n",
    "\n",
    "-->\n",
    "\n",
    "</pre>\n",
    "\n",
    "More comprehensive documentation of what entry types and corresponding sets of required and optional fields BibTex supports can be found in the [Wikipedia article on BibTex][wikibibt].\n",
    "\n",
    "Below is a section of the external bibliographic database for a fake history paper about the fictional island nation of Calico. (None of the entries contain information about real books or articles):\n",
    "\n",
    "[cc]: #5.2-Cite-Commands-and-Citation-IDs\n",
    "[wikibibt]: http://en.wikipedia.org/wiki/Markdown\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "\n",
    "&lt;!--bibtex\n",
    "\n",
    "@book{wellfarecut,\n",
    "    title = {Our Greatest Threat: The Rise of Anti-Wellfare Politics in Calico in the 21st Century},\n",
    "    author = {Jacob, Bernadette},\n",
    "    year = {2010},\n",
    "    publisher = {Jupyter University Press}\n",
    "}\n",
    "                  \n",
    "@article{militaryex2,\n",
    "    title = {Rethinking Calican Military Expansion for the New Century},\n",
    "    author = {Collier, Brian F.},\n",
    "    journal = {Modern Politics},\n",
    "    volume = {60},\n",
    "    issue = {25},\n",
    "    pages = {35 - 70},\n",
    "    year = {2012} \n",
    "}\n",
    "\n",
    "@article{militaryex1,\n",
    "    title = {Conservative Majority Passes Budget to Grow Military},\n",
    "    author = {Lane, Lois},\n",
    "    journal = {The Daily Calican},\n",
    "    month = {October 19th, 2011},\n",
    "    pages = {15 - 17},\n",
    "    year = {2011}\n",
    "}\n",
    "\n",
    "@article{oildrill,\n",
    "    title = {Oil Drilling Off the Coast of Jupyter Approved for Early Next Year},\n",
    "    author = {Marks, Meghan L.},\n",
    "    journal = {The Python Gazette},\n",
    "    month = {December 5th, 2012},\n",
    "    pages = {8 - 9},\n",
    "    year = {2012}\n",
    "}\n",
    "\n",
    "@article{rieseinterview,\n",
    "    title = {Interview with Up and Coming Freshman Senator, Alec Riese of Python},\n",
    "    author = {Wilmington, Oliver},\n",
    "    journal = {The Jupyter Times},\n",
    "    month = {November 24th, 2012},\n",
    "    pages = {4 - 7},\n",
    "    year = {2012}\n",
    "}\n",
    "\n",
    "@book{calicoww2:1,\n",
    "    title = {Calico and WWII: Untold History},\n",
    "    author = {French, Viola},\n",
    "    year = {1997},\n",
    "    publisher = {Calicia City Free Press}\n",
    "}\n",
    "\n",
    "@book{calicoww2:2,\n",
    "    title = {Rebuilding Calico After Japanese Occupation},\n",
    "    author = {Kepps, Milo },\n",
    "    year = {2002},\n",
    "    publisher = {Python Books}\n",
    "}\n",
    "-->\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2 Cite Commands and Citation IDs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you want to cite a bibliographic entry from a database (either internal or external), you must know the citation ID, sometimes called the \"key\", for that entry. Citation IDs are strings of letters, numbers, and symbols that *you* make up, so they can be any word or combination of words you find easy to remember. Once, you've given an entry a citation ID, however, you do need to use that same ID every time you cite that source, so it may behoove you to keep your database organized. This way it will be much easier to locate any given source's entry and its potentially forgotten citation ID. \n",
    "\n",
    "Once you know the citation ID for a given entry, use the following format to indicate to your Notebook's bibliographic support that you'd like to insert an in-text citation:\n",
    "\n",
    "<pre>\n",
    "[](&#35;cite-CITATION ID)\n",
    "</pre>\n",
    "\n",
    "This format is the cite command. For example, if you wanted to cite *Rebuilding Calico After Japanese Occupation* listed above, you would use the cite command and the specific citation ID for that source:\n",
    "\n",
    "<pre>\n",
    "[](&#35;cite-calicoww2:2)\n",
    "</pre>\n",
    "\n",
    "Before clicking the \"Generate References\" button, your unrendered text might look like this:\n",
    "\n",
    "\n",
    "<pre>\n",
    "Rebuilding Calico took many years &#91;](&#35;cite-calicoww2:2).\n",
    "</pre>\n",
    "\n",
    "\n",
    "After clicking the \"Generate References\" button, your unrendered text might look like this:\n",
    "\n",
    "\n",
    "<pre>\n",
    "Rebuilding Calico took many years &lt;a name=\"ref-1\"/>&#91;(Kepps, 2002)](#cite-calicoww2:2).\n",
    "</pre>\n",
    "\n",
    "\n",
    "and then the text would render as:\n",
    "\n",
    "\n",
    ">Rebuilding Calico took many years <a name=\"ref-1\"/>[(Kepps, 2002)](#cite-calicoww2:2).\n",
    "\n",
    "\n",
    "In addition, a cell would be added at the bottom with the following contents:\n",
    "\n",
    "\n",
    ">#References\n",
    "\n",
    "><a name=\"cite-calicoww2:2\"/><sup>[^](#ref-1) [^](#ref-2) </sup>Kepps, Milo . 2002. _Rebuilding Calico After Japanese Occupation_.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Turning Your Jupyter Notebook into a Slideshow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To install slideshow support for your Notebook, go [here](http://nbviewer.ipython.org/github/fperez/nb-slideshow-template/blob/master/install-support.ipynb).\n",
    "\n",
    "To see a tutorial and example slideshow, go [here](http://www.damian.oquanta.info/posts/make-your-slides-with-ipython.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. nbdev\n",
    "\n",
    "**A library that allows you to develop a python library in Jupyter Notebooks, putting all your code, tests and documentation in one place**\n",
    "\n",
    "> _[Literate programming](https://en.wikipedia.org/wiki/Literate_programming) is a programming paradigm introduced by [Donald Knuth](https://en.wikipedia.org/wiki/Donald_Knuth) in which a computer program is given an explanation of its logic in a natural language, such as English, interspersed with snippets of macros and traditional source code, from which compilable source code can be generated. According to Knuth, literate programming provides higher-quality programs by forcing programmers to explicitly state the thoughts behind the program. This process makes poorly thought-out design decisions more obvious. Knuth also claims that literate programming provides a first-rate documentation system, which is not an add-on, but is grown naturally in the process of exposition of one’s thoughts during a program’s creation._ \n",
    "\n",
    "- [Welcome to `nbdev`](https://nbdev.fast.ai)\n",
    "- [nbdev: use Jupyter Notebooks for everything](https://www.fast.ai/2019/12/02/nbdev)\n",
    "- [Nbdev: A literate programming environment that democratizes software engineering best practices](https://github.blog/2020-11-20-nbdev-a-literate-programming-environment-that-democratizes-software-engineering-best-practices)\n",
    "- [nbdev tutorial](https://nbdev.fast.ai/tutorial.html) - A step by step guide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. The executable book project\n",
    "\n",
    "> \"_An article about computational science in a scientific publication is not the scholarship itself, it is merely advertising of the scholarship. The actual scholarship is the complete software development environment and the complete set of instructions which generated the figures._\"<br>\n",
    "—D. Donoho ([1995](https://link.springer.com/chapter/10.1007/978-1-4612-2544-7_5))\n",
    "\n",
    "**The goal of the EBP is to build tools that facilitate creating professional computational narratives (books, lecture series, articles, etc.) using open source tools.**\n",
    "\n",
    "> _Jupyter Book is an open source project for building beautiful, publication-quality books, websites, and documents from source material that contains computational content. It is supported by the Executable Book Project, an open community that builds open source tools for interactive and executable documents in the Jupyter ecosystem and beyond._\n",
    ">\n",
    "> Jupyter Book (originally developed by Chris Holdgraf and Sam Lau with support of the UC Berkeley Data Science Education Program and the Berkeley Institute for Data Science) allows users to\n",
    ">\n",
    ">- write their content in [markdown](https://myst-parser.readthedocs.io/en/latest) files or Jupyter notebooks,\n",
    ">- include computational elements (e.g., code cells) in either type,\n",
    ">- include rich syntax such as citations, cross-references, and numbered equations, and\n",
    ">- using a simple command, run the embedded code cells, cache the outputs and convert this content into:\n",
    ">  - a web-based interactive book and\n",
    ">  - a publication-quality PDF.\n",
    "\n",
    "- [**The Executable Book Project**](https://executablebooks.org/en/latest)\n",
    "- [**Executable Books**](https://github.com/executablebooks) An open collaboration to create executable books with Jupyter\n",
    "- [**Creating an executable paper is a journey through Open Science**](https://www.nature.com/articles/s42005-020-00403-4) by Jana Lasser in _Communications Physics_ 2020;3(143)\n",
    "- [**The Scientific Paper Is Obsolete - Here’s what’s next**](https://www.theatlantic.com/science/archive/2018/04/the-scientific-paper-is-obsolete/556676) by by James Somers, _The Atlantic_, April 5, 2018."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "BMED360",
   "language": "python",
   "name": "bmed360"
  },
  "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}