03_ipython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How do Jupyter Notebooks work?\n",
    "\n",
    "You may have interacted with Jupyter notebooks before, but unless you've dabbled in the internals or IPython, you might not understand some of the finer points that will make some of the later points in this tutorial possible. Let's briefly review the basics.\n",
    "\n",
    "## What is a Jupyer Notebook?\n",
    "\n",
    "### Notebook Document\n",
    "\n",
    "Notebook documents (ending in `.ipynb`) are documents produced by the Jupyter Notebook App, which contain both computer code (e.g. python) and rich text elements (paragraph, equations, figures, links, etc…). In their raw form, they actually aren't very readable. You need to use the Jupyter Notebook App, or convert the notebook document to another format (like html or PDF) in order to view the human-readable components like you're used to.\n",
    "\n",
    "### Jupyter Notebook App\n",
    "\n",
    "The Jupyter Notebook App is a server-client application that allows editing and running notebook documents via a web browser. If you are following along with the tutorial, and not just looking at a converted document (like on github), you probably have the Jupyter Notebook App open."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How do Jupyter Notebooks run python code?\n",
    "\n",
    "### Python is an interpreted language\n",
    "\n",
    "All programming languages somehow need to turn human readable code, into something the computer understands. There are generally two ways to do this\n",
    "Python is an interpreted language, which means [no compilation and linking is necessary to run code](https://medium.com/@prithajnath/is-python-an-interpreted-language-2906e38f6e36).  \n",
    "\n",
    "If you don't know what complilation is, no worries. It's just important to know that python is an interpretted language, meaning that it is itself an executable program, and it is responsible for turning your code into machine code, executing it, and capturing the output.\n",
    "\n",
    "The point in all this being that the python interpreter has two 'modes' for running code. They may already be familar to you. \n",
    "The 'executable mode' is used when you execute full python files (ending with the `.py` extension) or packages. In this mode, the entire input is parsed before it is executed[*](https://docs.python.org/3/using/cmdline.html#interface-options).\n",
    "\n",
    "The other mode is for running code interactively (aptly called ['interactive mode'](https://docs.python.org/3/tutorial/interpreter.html#interactive-mode)), which makes it easy to experiment with features of the language, to write throw-away programs, or to test functions during bottom-up program development. This is what happens when you call python without arguments from your command line or from the python GUI called IDLE. This sort of interactive interpretter is also know as a REPL, or Read-Evaluate-Print Loop, because this is exactly what happens when you enter a line a send it to the interpreter. Depending on your version of python, the REPL looks something like this.\n",
    "\n",
    "```bash\n",
    "$ python\n",
    "Python 3.9 (default, June 4 2019, 09:25:04)\n",
    "[GCC 4.8.2] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "\n",
    "This dualistic behavior as both REPL and a scripting language is extremely similar to a UNIX shell (the language that powers your command line). Because of this, you may see the python interpreter colloquially refered to as the 'python shell'.\n",
    "\n",
    "### Python is not enough\n",
    "\n",
    "Python in it's traditional form isn't enough to run a Jupyter Notebook app. Why? Because python doesn't ship with a way to access the interpetter from more than one place. For example, if you were to open two tabs in your terminal, and start python in each one, there isn't any way to get them to talk to each other. (Thinking ahead, this is exactly what happens when you execute two different cells in a notebook.)\n",
    "\n",
    "Fortunately python is very 'extensible', meaning that if you know how to program in C, it is easy to add functionality to the python interpreter[*](https://docs.python.org/3/tutorial/appetite.html). This is exactly what the creators of IPython did.\n",
    "\n",
    "### IPython: an enhanced interactive Python shell\n",
    "\n",
    "[IPython](https://ipython.readthedocs.io/en/stable/overview.html) extends the python interpreter so that the interpretter can be accessed from multiple places. The 'client' part runs in one python instance, the 'computational' part runs in another python instance, and it all gets packaged into a single \"kernel\" that runs the communication between the two. By decoupling these two pieces to their own separate processes ([an instance of a program in execution](https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/3_Processes.html)), IPython makes it possible to access the interpretter from multiple places.\n",
    "\n",
    "You can use the IPython shell in your command line just like you would with regular python. The REPL looks like this.\n",
    "\n",
    "```bash\n",
    "$ ipython\n",
    "Python 3.7.4 (default, Aug 13 2019, 15:17:50) \n",
    "Type 'copyright', 'credits' or 'license' for more information\n",
    "IPython 7.12.0 -- An enhanced Interactive Python. Type '?' for help.\n",
    "\n",
    "In [1]:  \n",
    "```\n",
    "\n",
    "IPython goes beyond enhancing the python interpretter. It was designed to serve as a shell for the system (local machine). This means that if you really wanted to, you could change your command line settings to use the IPython shell instead of other popular UNIX shells like bash or zsh. So we will refer to the client as an InteractiveShell, because it actually is one.\n",
    "\n",
    "### IPython as a notebook kernel\n",
    "\n",
    "In the Jupyter Notebook App, the kernel is a “computational engine” that executes the code contained in a Notebook document. When using python, we use the IPython kernel, but many other languages are officially supported or are in development (R for example). Let's create an IPython client, or interactive shell, and use it to explore the kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import IPython\n",
    "\n",
    "ipython_client = IPython.get_ipython()\n",
    "ipython_client?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Jupyter, the interactive shell is of type ZMQ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ZMQInteractiveShell'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ipython_client.__class__.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you were to run this command from a regular command line, you would see that the class name would instead be called 'TerminalInteractiveShell'. \n",
    "\n",
    "Now let's explore the kernel through the client."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ipython_client.kernel?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the class docstring tells us that only one instance is allowed. ![https://jupyter.readthedocs.io/en/latest/projects/architecture/content-architecture.html](img/notebook_components.png)\n",
    "\n",
    "While the notebook may have many interactive clients (the one that runs each cell and the other one we just created my running the above code cell), they all talk to the same computational engine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}