2017-05-19 PyCon Notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10:50 AM: Requests under the hood\n",
    "\n",
    "[Cory Benfield](https://lukasa.co.uk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[This is the requests library](https://github.com/kennethreitz/requests)\n",
    "\n",
    "Why does code get messy?\n",
    "* \"You end up with a function where the only defined behavior is ... well it does whatever it does now, so let's not mess with it\"\n",
    "* \"When it works, we don't think about it\"\n",
    "* Pragmatism\n",
    "* The quick hacky fix is never temporary.\n",
    "* Users don't complain about it\n",
    "* Over time you enshrine every edge case ever into your code.\n",
    "* Things are complex AND they evolve\n",
    "\n",
    "\n",
    "**Hero-worship, while fine, is fundamentally predicated on a lie. Our heros are not dramatically better at writing better code than us**\n",
    "\n",
    "* Any non-trivial software is flawed.\n",
    "* We need to not be afraid of our mistakes.\n",
    "\n",
    "Questions/Discussions:\n",
    "* How do you balance the need to do things right with a need to immediately fix things? At some point, the hacks are okay, but acknowledge that they are hacks.\n",
    "* Is it possible to deossify a codebase? When the combined weight of all the historical decisions make it impossible to keep up, someone else will probably come up with something better."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11:30 AM: Type uWSGI; Pres Enter; What Happens?\n",
    "\n",
    "[Asheesh Laroia](https://github.com/paulproteus); [Philip James](https://twitter.com/phildini)\n",
    "\n",
    "Previous talk: Type Python pres enter, what happens\n",
    "\n",
    "\n",
    "[Youtube link](https://www.youtube.com/watch?v=XVhSjZYwZJo)\n",
    "\n",
    "[Slides](https://speakerdeck.com/phildini/type-python-press-enter-what-happens-pydx-2015)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running UWSGI\n",
    "\n",
    "```bash \n",
    "uwsgi --master --http :8000 --module catserve.wsgi \n",
    "```\n",
    "\n",
    "**How does uWSGI handle processes?**\n",
    "\n",
    "* WSGI is a synchronous protocol\n",
    "\n",
    "To un-ruin the service, run two worker processes, and there are now 2 uWSGI workers.\n",
    "```bash \n",
    "uwsgi --master --http :8000 --module catserve.wsgi -p 2\n",
    "```\n",
    "\n",
    "**How does uWSGI handle networking?**\n",
    "\n",
    "* Userland communicates with the kernel through syscalls\n",
    "\n",
    "To connect to the uWSGI server?\n",
    "1) uWSGI needs to issue the socket syscall to issue the socket that will connect to the port on the kernel\n",
    "    * uWSGI is getting back a way of handling the socket\n",
    "2) Bind connects the port to the socket\n",
    "3) Listen() tells the kernel to expose the port and make it available for listening\n",
    "4) This is when uWSGI spawns its workers. Keeps initial file descriptors. These worker processes issue epoll_wait() which tell the kernel that they are ready and waiting for any connections.\n",
    "\n",
    "So...when the browser opens the port:\n",
    "* Both processes try to \"pick up the phone\"\n",
    "* One wins, and handles the connection through a separate socket.\n",
    "\n",
    "**Why use uWSGI?**\n",
    "* Graceful code reloading\n",
    "* Tuneability\n",
    "* Security\n",
    "* Making config files\n",
    "* Other features\n",
    "\n",
    "How does code reloading work?\n",
    "\n",
    "* With a new version of the code\n",
    "* uWSGI sends sighup to the worker processes\n",
    "* uWSGI tells anything not working to stop, and marks another one that it \"needs to exit\" after\n",
    "* Always checks if it should exit before calling the epoll_wait()\n",
    "* uWSGI erases its memory and creates a new process with the same pid and same socket, which never closes: thus can queue new code.\n",
    "* Always waits for all worker processes to exit, and by default waits 60 seconds. You can make it reload worker processes one by one.\n",
    "\n",
    "**Making sure the resource usage meets your needs**\n",
    "* The `-p` parameter lets you change the # of processes\n",
    "\n",
    "**Security**\n",
    "\n",
    "> \"Security is a word, that when you say it, everyone in the room feels inadequate\"\n",
    "\n",
    "```\n",
    "GET / HTTP/1.1\n",
    "HOST: catserve.io\n",
    "```\n",
    "vs. \n",
    "```\n",
    "GET / HTTP/1.1\n",
    "HOST: catserve.io\n",
    "HOST: catserve.biz\n",
    "```\n",
    "\n",
    "* Interactions between the thing running your code and the rest of the stuff it runs could turn into security issues\n",
    "\n",
    "** Config Files **\n",
    "\n",
    "Translate the bash command from the beginning int:\n",
    "```\n",
    "[uwsgi]\n",
    "master = 1\n",
    "http = 8000\n",
    "module = catserve.wsgi\n",
    "processes = 2\n",
    "```\n",
    "\n",
    "**Features**\n",
    "* Static file serving (high performance implementation in C)\n",
    "* Max requests per worker\n",
    "* Queuing systems\n",
    "* HTTPS support, HTTP2 support\n",
    "* uwsgitop\n",
    "* memory-report\n",
    "* async"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12:10 PM Grokking the GIL: Write Fast and Thread Safe Python\n",
    "[Jesse Jiryu Davis](https://twitter.com/jessejiryudavis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're going to look at Python 2.7 source code. \n",
    "\n",
    "['This is the GIL'](https://github.com/certik/python-2.7/blob/master/Python/ceval.c)\n",
    "\n",
    "GIL:\n",
    "* Mutual exclusion lock\n",
    "* Initialized at the beginning of interpreter start up\n",
    "* The GIL is born locked by the main thread\n",
    "* Mutex is a lock that threads have to hold whenever they are executing Python code\n",
    "\n",
    "> One thread runs Python, while N others sleep or await I/O.\n",
    "\n",
    "All of your threads can be doing other things. The only thing that two threads can't do at once in Python is run Python.\n",
    "\n",
    "> \"I like to think of my Python programs as an old mainframe computer.\"\n",
    "\n",
    "We want to know how to write fast and thread-safe python with CPython today?\n",
    "\n",
    "2 Kinds of Python multitasking\n",
    "* Cooperative: voluntarily dropping the GIL while this thread does something else\n",
    "* Preemptive: interpreter forces a thread to drop Python\n",
    "    * Happens every 1K bytecodes in Python2.\n",
    "    * Happens every 15 milliseconds.\n",
    "    \n",
    "    \n",
    "**Cooperative**\n",
    "    \n",
    "`Py_BEGIN_ALLOW_THREADS`\n",
    "   \n",
    "[Socket Connection source code here](https://github.com/certik/python-2.7/blob/c360290c3c9e55fbd79d6ceacdfc7cd4f393c1eb/Modules/_multiprocessing/socket_connection.c)\n",
    "```c\n",
    "Py_BEGIN_ALLOW_THREADS\n",
    "res = _conn_sendall(conn->handle, message, length+4);\n",
    "Py_END_ALLOW_THREADS\n",
    "```\n",
    "\n",
    "\n",
    "**Preemptive**\n",
    "\n",
    "Two step Python execution:\n",
    "* Python text compiled into bytecode\n",
    "* Byteode interpreted by the interpreter, executes like a little VM according to the instructions in ceval.c\n",
    "\n",
    "[Back to ceval.c](https://github.com/certik/python-2.7/blob/master/Python/ceval.c)\n",
    "\n",
    "Debuggers register trace functions, which the interpreter executes every time it starts a function call. \n",
    "` if (tstate->c_profilefunc != NULL)`\n",
    "\n",
    "This is where the GIL forces preemptive multithreading\n",
    "> `/* Give another thread a chance */` \n",
    "\n",
    "**How do we use this to write fast code?**\n",
    "\n",
    "* Cooperative multitasking: finish jobs faster if jobs are to primarily await i/o.\n",
    "* Preemptive multitasking: simulate parallelism.\n",
    "\n",
    "If there's a GIL, do we need to worry about thread safety?\n",
    "\n",
    "Unsafe:\n",
    "```python\n",
    "import threading, sys\n",
    "sys.setcheckinterval(1)\n",
    "\n",
    "n=0\n",
    "\n",
    "def foo():\n",
    "    global n\n",
    "    n +=1\n",
    "\n",
    "threads = []\n",
    "\n",
    "for i in range(1000):\n",
    "    t = threading.Thread(target=foo)\n",
    "    threads.append(t)\n",
    "\n",
    "for t in threads:\n",
    "    t.start()\n",
    "\n",
    "for t in threads:\n",
    "    t.join()\n",
    "\n",
    "print(n)\n",
    "```\n",
    "\n",
    "Sometimes returns 1000, sometimes returns 998.\n",
    "\n",
    "* Have to lock around shared mutable state\n",
    "\n",
    "**So how do we make code go fast?**\n",
    "* Concurrency: when a job finishes faster by waiting for multiple i/o operations at the same time.\n",
    "* Parallelism: when a job finishes faster when multiple threads do things at the same time.\n",
    "    * Python threads can't do this\n",
    "\n",
    "\n",
    "How to use threads to make a concurrent task go faster. For an i/o bound task, threads can be a good answer.\n",
    "\n",
    "How to use do parallelism despite the GIL.\n",
    "* Proceses are completely distinct; they have independent GILs and can run simultaneously on multi-core laptops\n",
    "    * Communication is a lot more complex\n",
    "* Threads share memory\n",
    "\n",
    "[Article version of the talk with code](https://emptysqua.re/blog/series/grok-the-gil/)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4:30 PM: The Glory of pdb's set_trace\n",
    "\n",
    "Nicole Zuckerman"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Inspect variables in real-time\n",
    "* Pretty print things and can see variables\n",
    "* look at backtrace of current function\n",
    "```\n",
    "(pdb) bt\n",
    "```\n",
    "* Look at whatever variables are in that context\n",
    "* Can move up or move down the call stack\n",
    "* Traveling through execution.\n",
    "* q doesn't cleanup\n",
    "* `l` or `list` allows you to view 5 above and 5 below the lines you're on.\n",
    "* Changing live code real-time \n",
    "\n",
    "\n",
    "**Other debugging tools**\n",
    "\n",
    "Dunder dicts\n",
    "`foo.__dict__`\n",
    "\n",
    "dir\n",
    "`dir(obj)`\n",
    "\n",
    "**Pdb gotchas**\n",
    "* Harder when code is not running in a place wiht a prompt (celery, cron job)\n",
    "* Try not to name variables that would collide with a pdb command version\n",
    "* `help` tells you what commands are available\n",
    "* Hitting the \"enter\" key will reexecute a command like ```!!``` in bash\n",
    "\n",
    "**Post-moterm debugging**\n",
    "* `pdm.pm` takes no arguments and will enter post-mortem debugging of the last traceback.\n",
    "* But if you use pdb.post_morten you can trace it back to something\n",
    "* Breakpoints are numbered or you can give it a file name before the line number\n",
    "* Conditional breakpoints or setting breaks at particular functions.\n",
    "* Can drop into a pdb if/when a test fails."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5:10 PM : Algorithmic Music Generation\n",
    "Padmaja V Bhagwat\n",
    "\n",
    "[Github](https://github.com/unnati-xyz/music-generation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Steps to algorithmically generate music?\n",
    "\n",
    "1. Convert mp3 files to np-tensors\n",
    "2. Train the model\n",
    "3. Generate the music\n",
    "\n",
    "**To convert the mp3 files to np-tensors**\n",
    "* Uncompress the music: mp3 to monaural WAV using LAME\n",
    "* Divide into blocks of equal size by zero padding it\n",
    "* Convert from time to frequency domain using discrete fourier transform\n",
    "    * Use a RNN that remembers previous information\n",
    "    * LSTM: remembering information for a longer period of time that is something that model does by default?\n",
    "    \n",
    "LSTM Steps\n",
    "* Forget gate layer\n",
    "* Input gate layer + tanh layer decides what to update\n",
    "* Old cell state gets updated\n",
    "* Sigmoid layer decides output\n",
    "\n",
    "Generating music\n",
    "* Taking first chunk of training data as seed sequence\n",
    "* Iteratively add sequences to the seed\n",
    "\n",
    "**Challenges**\n",
    "* Data intensive\n",
    "* Memory intensive (32 GiB of memory, 8vCPUs, EBS-only, 64 bit platform)\n",
    "* 14 hours to do 2K iterations\n",
    "\n",
    "** Python libraries**\n",
    "* LAME and SoX to convert mp3 files\n",
    "* Numpy/Scipy\n",
    "* Matplotlib\n",
    "* Used Keras with Theano as backend\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}