Development Environment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Development Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  1. [Getting Python](#Getting-Python)\n",
    "    1. Which version should I use?\n",
    "    1. Where to get Python\n",
    "       - Python.org\n",
    "       - Anaconda\n",
    "  1. [IDEs](#IDEs)\n",
    "    1. PyCharm\n",
    "    1. Sublime is not an IDE\n",
    "  1. [REPLs](#REPLs)\n",
    "    1. Python\n",
    "    1. IPython / Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Which version should I use?\n",
    "\n",
    "If this is the first you've read about Python, you may not be aware of the controversial nature of this question. Two major versions of Python are in use today, Python 2 and Python 3. From a distance, the core differences seem relatively minor, with the obvious exception that Python 2 is no longer being actively improved (except for security patches). There are some breaking changes, and not all code can be easily used in both versions. There is a vocal group that posits that Python 2 is necessary in order to get a Python job. Their reasoning is: there a lot of legacy code that businesses would find to be economically infeasible to refactor, and in some cases, the code relies on libraries which are no longer maintained and cannot be easily ported to Python 3. While this notion has merit, the reality is far less bleak. In my experience, when an assessment of the language benefits and improvements are considered, there is little trouble getting approval to start new projects in Python 3. Additionally, the practical differences are not going to prevent a Python 3 developer from reasonably being able to maintain this legacy code. As a Python beginner, the only relevant difference you’re are likely to notice is that `print` is a statement in Python 2, and a function in Python 3. My suggestion is to move forward with Python 3, and when you're comfortable with the language, research the differences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Where to get Python\n",
    "\n",
    "The following information is relevant for Mac and Windows users. Linux users will have other options, depending on distribution and version. I intend to include information on this in the future. If you are running on a Mac, you may have realized that Python 2.6 is included on your computer. I recommend that you install the latest version."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Python.org\n",
    "\n",
    "[Python.org](https://www.python.org) is a great place for most users to download and install the latest package for your operating system. As stated earlier, I suggest that you concentrate your efforts on learning and using Python 3 as your primary interpreter. With that said, I recommend that you also install the latest version of Python 2, since there is still a number of applications and libraries that do not support Python 3, and it is good to be familiar with how to run either version. Python comes with two package managers, `easy_install` and `pip`, with the latter being preferred. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Anaconda\n",
    "\n",
    "[Anaconda](https://www.continuum.io) offers many benefits as a complete scientific computing package. What sets Anaconda apart from vanilla Python is that it is bundled with a package manager called `conda`, and many of the available libraries have been pre-compiled for maximum performance on your system. This means that you do not need a build system (e.g. Visual Studio on Windows) to install these libraries, and that in most cases the optimal settings for the library have been determined and implemented across the available platforms. `pip` can still be used to install libraries for which a pre-compiled package does not exist. When it comes to distributing your completed application, there will be additional considerations about how to install dependencies, like where to obtain each library, and what versions are known to work. An additional note about `conda` is that it is also used to create \"virtual environments\", which gives you the ability to create separate development environments for your various projects. Creating virtual environments and \"freezing\" dependency requirements (library names and version numbers) will be discussed later.\n",
    "\n",
    "*Note: If you want to take advantage of Anaconda's package manager and pre-compiled libraries, but don't need all of the bundled scientific computing libraries, you can install [Miniconda](http://conda.pydata.org/miniconda.html) for a custom experience.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IDEs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### PyCharm\n",
    "\n",
    "[PyCharm](https://www.jetbrains.com/pycharm/) is a fantastic IDE that offers a many useful development features. There is a community edition that is free for individual use (though some features are withheld). The reason that I prefer using an IDE like PyCharm is because most of the useful plugins are already included in one package. A very incomplete list of features PyCharm offers out of the box: syntax highlighting, code completion, code formatting, world-class integration with the debugger, integration with `pip` and `conda` package managers, test runner, profiler, and version control system integration.\n",
    "\n",
    "For advanced users, I highly recommend purchasing a license because there are some features that are not included in the community edition. An [early access program](https://confluence.jetbrains.com/pages/viewpage.action?pageId=23004355) (EAP), when available, includes all of the features and does not require a license. The EAP edition will have access to the latest features before they're released, but be warned that occasionally there will be new bugs introduced."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sublime is not an IDE\n",
    "\n",
    "Sublime Text is an amazing text editor. I use it in combination with PyCharm, but rarely for writing code. For the few things that PyCharm is unsuited for (like viewing and editing very large files), I find that Sublime fills the gap quite nicely. Sublime offers a package manager and a large repository of community developed plugins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### REPLs\n",
    "\n",
    "A REPL (read–eval–print loop) is an interactive programming environment that takes a statement, evaluates it, and displays (returns) the result. They are great for testing out code or quickly iterating on and refining an algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python\n",
    "\n",
    "For basic things, the built-in Python REPL is extremely useful. Starting it is often as simple as running `python` from the command line:\n",
    "\n",
    "```\n",
    "python ⏎\n",
    "\n",
    "Python 3.5.1 (v3.5.1:37a07cee5969, Dec  5 2015, 21:12:44) \n",
    "[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### IPython / Jupyter notebook\n",
    "\n",
    "IPython offers advanced tools like code completion, dynamic object information, persistent command history. Jupyter notebook extends IPython with a powerful web browser interface that allows creating sharable notebook files. With Jupyter notebook it is easy to design algorithms and perform complex scientific data analysis with graph results, all without the need for an IDE. There will more on this topic later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "def say_something(text):\n",
    "    print(text)\n",
    "    \n",
    "say_something('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### To install and run Jupyter notebook:\n",
    "\n",
    "```\n",
    "pip install jupyter ⏎\n",
    "jupyter notebook ⏎\n",
    "\n",
    "(default web browser loads)\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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}