notebook-01-getting-started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "# Notebook-1: Getting Started"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## This is a Jupyter Notebook\n",
    "\n",
    "There's no reason you'd know this yet, but the web page you're looking at is also known as a 'Jupyter notebook' -- it's why you can 'run' code as part of the web page. Check out this example by clicking in the box (next to the <span style=\"color:blue;font-family:monospace\">In [ ]</span>) and hitting the 'run' button in the toolbar above or typing Ctrl+Return at the same time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "outputs": [],
   "source": [
    "print('Hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If all has gone well you should have seen `Hello world` appear on a line all on its own. That was Python code running in a notebook. Here's some more code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( (1+2+3+4)/4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check that this gave you the right answer at the bottom of this page. \n",
    "\n",
    "Anyway, because of their history, some people will call these \"iPython notebooks\", others will call them \"Jupyter notebooks\", and some will just stick with \"notebooks\". They are all the same thing. \n",
    "\n",
    "Here's some more code to run as proof that this is actual code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "You don't need to understand all of that output, the point is that this is Python and we can do anything in a notebook that we would in a program.\n",
    "\n",
    "Rather than throw you in at the deep end with examples taken from computer science classes, for Code Camp we've tried to give you _geographical_ examples whenever possible in the hopes that the early examples will seem a _little_ less abstract and a _little_ more relevant to _your_ needs. Of course, the early examples are also very basic so the payoff might not be obvious right away, but trust us: if you stick with it you will start to change your thinking about geography as a discipline and about the power of computers to transform _everything_.\n",
    "\n",
    "So, before we do any more coding, let's think about why might want to use this technology in geography."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "# Programming and Geography \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## The Fall and Rise of Geocomputation\n",
    "\n",
    "We live in a world transformed by big (geo)data: from Facebook likes and satellites, to travel cards and drones, the process of collecting and analysing data about the world around us is becoming very, very cheap. Twenty years ago, gathering data about the human and physical environment was expensive, but now a lot of it is generated as the ‘exhaust’ of day-to-day activity: tapping on to the bus or train, taking photos (whether from a satellite, drone, or disposable camera), making phone calls, using our credit cards, and surfing the web. And that's before you start looking at the Terabytes of data being generated by satellites, air quality and river flow sensors, and other Earth Observation Systems! \n",
    "\n",
    "As the costs of capturing, curating, and processing these data sets falls, the discipline of geography is changing. You face a world in which many of the defining career options for geographers with basic quantitative skills will either no longer exist, or will have been seriously de-skilled. So much can now be done through a web browser (e.g. [CartoDB](https://carto.com)) that specifying ‘Knowledge of ArcGIS’ is becoming superfluous; not because geo-analysis jobs are no longer in demand or no longer done -- in fact, they are more vital than ever -- but because the market for these skills has split in two: expensive, specialist software is being superseded by simple, non-specialist web-based tools on the ‘basic’ side, and by customised code on the 'advanced' side.\n",
    "\n",
    "It is for these reasons that terms like 'geocomputation', 'computational geography' and 'geographic data science' are back in vogue. After a period in which GIS was front-and-centre for many geographers with an interest in spatial data (as well for many geographers who objected to the shortcomings of quantitative approaches), the availability of data and advanced computational techniques (including Machine Learning), together with the 'discovery' by other disciplines of the role of geography in 'big data' processes, has created a need for a 'new' (or old, depending on your view) type of geographer able to reason much more directly _through_ code while remaining rooted in the critical geographic tradition that is aware of the short-comings (and opportunities) of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## What is Geocomputation?\n",
    "\n",
    "Computational approaches -- which is to say, approaches to geography using computers executing commands written in programming code -- differ in important ways from the quantitative skills taught in traditional geography ‘methods’ classes: computational geography is underpinned by algorithms that employ concepts such as *iteration* and *recursion*, and we use these to tackle everything from a data processing problem to an entire research question. \n",
    "\n",
    "For example, we can see Alex Singleton’s OpenAtlas for Camden [Camden Open Atlas](https://opendata.camden.gov.uk/People-Places/2011-Census-Open-Atlas-Camden/jiah-9evi). Alex designed and wrote a script to _iterate_ over the Census areas (i.e. to ‘visit’ each area in turn when creating a map), and to _recurse_ into smaller sub-regions from larger regions (i.e. to keep drilling down into smaller and smaller geographies) in order to generate maps at, literally, every conceivable scale. Then he let the computer do the ‘boring bit’ of actually creating each and every map. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### Thinking Algorithmically\n",
    "\n",
    "Thinking _algorithmically_ requires students and professionals to deal with abstraction: we don’t want to define how each analysis should work – or how each map should look – rather, we want to specify a set of rules about how to select and display data on a map, and then let the computer make them all for us. In this way of working it’s not really any more work to create 500 or 5,000 maps than it is to create 5 because we’ve already told the computer how to make useful maps. \n",
    "\n",
    "Here's another way to think about it:\n",
    "\n",
    "> _An algorithm is like a recipe. It takes \"inputs\" (the ingredients), performs a set of simple and (hopefully) well-defined steps, and then terminates after producing an \"output\" (the meal)._\n",
    "\n",
    "This article also goes on to make some interesting points about AI and deep learning that are [well worth a read](https://medium.com/@geomblog/when-an-algorithm-isn-t-2b9fe01b9bb5), but for our purposes, the bit about a *recipe* is the important bit: how would you break your problem down into steps *like the ones you'd see for a recipe*?\n",
    "\n",
    "Learning to think this way is *hard work*: the *first* time I try a new recipe I really don't know how things are going to taste. Similarly, the first time I use an algorithm to make a map or solve a problem I usually don't actually know exactly how my maps are going to look until _after_ I've made them. The difference from the 'normal', non-computational way of working is that I make a few changes to my code and then just run it again. And again... as many times as I need to in order to get what I want. I can keep changing the recipe until I get it just right."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### Thinking Like a Programmer\n",
    "\n",
    "However, trying the same recipe again and again and again _also_ sounds like hard work! Wouldn't it be faster to just click and choose what you want the computer to do in SPSS or ArcMap? Well, yes and no. The two advantages to doing this with code over pointing-and-clicking are: 1) your solution is _transferrable_; and 2) thinking 'like a programmer' is also about problem-solving, and that _also_ transfers very nicely to the 'real world' of employment.\n",
    "\n",
    "Why do we say this:\n",
    "\n",
    "1. Programming solutions are transferrable because you aren't just solving _one_ problem, you are solving _classes_ of problems. In the same way that many recipes build on the same basic ingredients (sometimes adding something new for added 'spice'), many applications use the same basic ingredients: it's how they're put together in new ways that lead to new outputs. It's a lot like Lego.\n",
    "\n",
    "2. Thinking like a programmer also translates well because you are learning to deal with abstraction. Yes, the details of a problem matter (just as ignoring cultural differences between two countries can matter), but it's important to be able to break a really big, messy, complex problem down into smaller, tidier, more comprehensible bits that you _can_ tackle. Programmers deal with this every day, so they tend to develop important skills in understanding and dealing with practical challenges of the sort that you'll face every day in your career.\n",
    "\n",
    "Here's another [useful bit of insight](https://medium.freecodecamp.org/how-to-think-like-a-programmer-lessons-in-problem-solving-d1d8bf1de7d2?source=userActivityShare-65ab89778550-1526122060&gi=f9005e8aacb5):\n",
    "\n",
    "> The best way \\[of solving problems\\] involves a) having a framework and b) practising it.\n",
    "> \n",
    "> Problem-solving skills are almost unanimously the most important qualification that employers look for... more than programming languages proficiency, debugging, and system design...\n",
    ">\n",
    "> — Hacker Rank (2018 Developer Skills Report)\n",
    "\n",
    "You really should [read the article](https://medium.freecodecamp.org/how-to-think-like-a-programmer-lessons-in-problem-solving-d1d8bf1de7d2) (it's not very long) but here are the key points:\n",
    "\n",
    "1. Understand the problem -- most problems are hard because you don't understand them _and_ you will only know that you've understood it when you can explain it in plain-English.\n",
    "2. Plan -- if you just dive in without thinking about what you need your code to take in and spit out then you're going to waste a _lot_ of time.\n",
    "3. Divide -- break a hard problem down into simple, small steps and tackle them in small, simple blocks of code. _Never_ try to just sit down and 'code'.\n",
    "4. Debug with a fresh eye -- if you really feel stuck, step away from the computer for 5 minutes, take a deep breath, and try to look at the problem with a fresh set of eyes rather than just diving back in. Most problems boil down to either not seeing the big picture, or not realising that the computer is doing _exactly what you told it to do_, and _not what you meant for it to do_.\n",
    "5. Practice -- find ways to practice problem-solving and coding (not necessarily at the same time).\n",
    "\n",
    "If you don't take our word for it, how about taking Richard Feynman's word on it?\n",
    "\n",
    "> If you can’t explain something in simple terms, you don’t understand it.\n",
    "\n",
    "<img src=\"https://kottke.org/plus/misc/images/feynman-blackboard.jpg\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### The Open Source Ethos\n",
    "\n",
    "Once I've got a solution to my current problem, I can take that code and apply it to a new problem. Or a new case study. _Or_, I can [post it online](https://github.com/kingsgeocomp) and let others build off of my work to tackle problems that I've not even considered! Giving away my code might seem like a bad idea, but think about this: in a world of exciting research questions, are you going to be able to tackle every single one? Your own work _already_ builds off of code that other people gave away (the Mac OS, Linux, QGIS, Python, etc.)... perhaps you should give something back to the community? Not _just_ because it's a nice thing to do, but because people will find out about you through your code. And those people might be in a position to offer you a job, or they might approach you as a collaborator, or they might point someone else with an interesting opportunity in your direction because you have built a reputation as a 'contributor'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### Further Reading \n",
    "\n",
    "A big gap is opening up between the stuff that can be done by pushing buttons (which no longer even really requires geographical training) and the 'cutting edge'. There are many pieces that argue this case, but here are a few to start with:\n",
    "\n",
    "* [Why the Future of Geography is Cheap](https://www.rgs.org/schools/teaching-resources/why-the-future-of-geography-is-cheap/)\n",
    "* [GIS Jobs of Today](http://www.directionsmag.com/entry/gis-jobs-of-today-should-you-have-programming-skills/473296): should you have programming skills?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "# Why Learn to Code?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Why _you_ should learn to program\n",
    "\n",
    "There are many good reasons for geographers to learn to code, but let's start with some good _general_ reasons why _you_ should learn to program a computer even if you never use it to make a map or complete a bit of spatial analysis.\n",
    "\n",
    "> You should learn how to program a computer because it teaches you how to think.\n",
    "\n",
    "[![Why You Should Learn How to Code](http://img.youtube.com/vi/Dv7gLpW91DM/0.jpg)](https://youtu.be/Dv7gLpW91DM)\n",
    "\n",
    "And here is a useful perspective on whether or not learning to code is hard:\n",
    "\n",
    "> If you don't have a reason for learning to code outside of trying making lots of money that's not a very long term passion... but when you have an idea or a problem that you're passionate about solving then that's why we keep on going... but do you need to have an understanding of complex math or logic skills, the answer is no.\n",
    "\n",
    "[![Is Learning to Code Hard](http://img.youtube.com/vi/k7Txbdvzx90/0.jpg)](https://youtu.be/k7Txbdvzx90)\n",
    "\n",
    "So while 'making money' is (often) a nice outcome of learning to code, having a passion for what you want to _do_ with your code is what's going to get you through the worst parts of the learning curve. You also need to be realistic: to become a professional programmer is something that happens over many years, you probably won't just take a couple of classes and then go out into the world saying \"I'm a programmer.\"\n",
    "\n",
    "And, no, you do _not_ need to know advanced maths in order to learn how to code: you need to be able to think logically and to reframe your problems in ways that align _with_ the computer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## The Benefits of Coding?\n",
    "\n",
    "In a practical context we think that the benefits of learning to code fall into three categories:\n",
    "1. **Flexibility**: a computer can often apply the _same_ analytical process to a completely different data set (_e.g._ rainfall in UK vs rainfall in the US) with minimal effort compared to trying to do each step manually in, say, Excel or SPSS. For students, it comes down to this: if you discover a newer, better data set halfway through your dissertation and want to use this for your analysis instead of the old, inaccurate data, it's a lot easier and faster to update your analyses if you have used code to do the analysis to-date!\n",
    "2. **Reproducibility**: recently, it's been discovered that a lot of research cannot be reproduced. In other words, if one scientist tries to duplicate what someone else did in order to check something out (as is important in the scientific method) they're finding that the results don't line up. So a second example of why coding your data analysis for a dissertation: you've just finished your analysis when someone points out that you made a mistake with the data right back at the beginning; redoing all of that in Excel or SPSS would be a nightmare, but with code, it can be as easy as changing one line and hitting 'Run'!\n",
    "3. **Scalability**: a computer doesn't care if you throw 10 lines or 10 billion lines at it, the only thing that changes is how long it takes to get an answer. In other words, if your code 'works' on a subset of your data it should also work on your entire data set no matter how big it is. This is also a good way to develop code: rather than try to read in the whole data set in one go while you're still trying to understand it, take a few rows and make sure you're handling _those_ ones correctly (and if what you see squares with what you were told) before expanding to larger and larger subsets.\n",
    "\n",
    "Often, the payoff for coding the answer to a problem instead of just clicking through the options in SPSS or Arc can seem a long way away. It's like learning a new language: you spend a lot of time asking directions to the train station or whether someone had a nice breakfast before you can start work on the novel or the business case. But the payoff _is_ there if you stick with it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## The 3 virtues of a programmer\n",
    "\n",
    "Another useful idea comes from [Larry Wall](https://en.wikipedia.org/wiki/Larry_Wall) (the man with the strong 'tache game below!), who created a programming language called Perl. Larry said that programmers had three virtues: **Laziness, Hubris, and Impatience**. \n",
    "\n",
    "<img src=\"http://cdn.quotationof.com/images/larry-wall-1.jpg\" width=\"250\">\n",
    "\n",
    "Some of the reasons that these are virtues in programming (but not in your studies!) are as follows:\n",
    "\n",
    "1. **Laziness** makes you want to put in the effort _now_ to reduce the amount of effort you'll have to put in _later_. It might be a lot of work to produce a map of _one_ US State automatically using code, but once you've worked out how to do it for one state, then you've also figured out how to do it for _all 50_! That is useful laziness.\n",
    "2. **Hubris** makes you want to write code that other people won't want to \"say bad things about\". Over time you'll come to understand more intuitively what makes 'good' code in more detail (and we cover it a bit in the last notebook), but the short version is: it's efficient, it's easy to read, and it's clever.\n",
    "3. **Impatience** is about wanting the answer _now_ and looking for ways to get _there_ as quickly as possible. Being impatient doesn't mean just jumping into writing code, it means that you _first_ look too see whether and how other people have solved similar problems before starting work on your own code. Rather than reinventing the wheel, we try to stand on the shoulder of giants.\n",
    "\n",
    "**_Hint_**: you'll see a lot of laziness when you start trying to write code. Programmers don't like writing **`remove`** when they could just write **`rm`**, nor do they like writing **`define`** when they could just write **`def`**. Keep an eye out for these mnemonics as they can be pretty daunting at first."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### The 3 false virtues\n",
    "\n",
    "Larry also pointed out that these virtues had three mirror-image false virtues:\n",
    "\n",
    "1. **False laziness** happens when you leave something working but half-finished and, most likely, about to break. When you start using [StackOverflow](http://www.stackoverflow.com/) you may find that it makes it easy to copy+paste answers into your notebook and then you can glue it together messily. This isn't the same as _understanding_ and _adapting_ the solution that you found online to _your_ problem, so it's false laziness. To really develop a learning mindset, [don't copy+paste code, type it out](https://medium.freecodecamp.com/the-benefits-of-typing-instead-of-copying-54ed734ad849#.es5mw1j0z). \n",
    "2. **False hubris** is thinking that no one else's code is 'good enough' for you. Sometimes copy+paste is false laziness, but refusing to recognise when copy+paste (or importing a library, more on this later) _is_ the right thing to do is false hubris.\n",
    "3. **False impatience** is getting started on coding your answer to a problem when you don't yet understand what the problem actually _is_. One thing that a lot of programmers do is half-listen to what someone has asked them to do and then go haring off without sitting down to make any kind of plan. It's like writing an essay without having done the readings. Nudge, nudge.\n",
    "\n",
    "There's a lot more thinking on this here: http://blog.teamtreehouse.com/the-programmers-virtues"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## On Accessible Code\n",
    "\n",
    "In the early days of computing, programs weren't even written in English (or any other human language), they were written in Assembly/Machine Code. One of the people who thought that was crazy was this rather impressive Rear Admiral:\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/a/ad/Commodore_Grace_M._Hopper%2C_USN_%28covered%29.jpg/960px-Commodore_Grace_M._Hopper%2C_USN_%28covered%29.jpg\" width=\"300\" />\n",
    "\n",
    "[Grace Hopper](https://en.wikipedia.org/wiki/Grace_Hopper) felt that applications should be written in a way that more people could understand; this would be good for the military, but it would also be good for business and society in general. For her efforts, she is now known as the Mother of COBOL (the COmmon Business Oriented Language), a language that is still in (some) use today. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Being a 'good' programmer\n",
    "\n",
    "The best way to be a 'good' programmer is to know when the computer can help you and when it will just get in the way. A computer cannot 'solve' a problem for you, but it _can_ help you to find the answer when you've told it what to look for and what rules to use in that search. A computer can only do _exactly_ what you tell it to do, so if you don't know what to do then the computer won't either.\n",
    "\n",
    "One of the founders of computing, [Charles Babbage](https://en.wikiquote.org/wiki/Charles_Babbage#Passages_from_the_Life_of_a_Philosopher_.281864.29) had this to say:\n",
    "\n",
    "> On two occasions I have been asked, — \"Pray, Mr Babbage, if you put into the machine wrong figures, will the right answers come out?\" In one case a member of the Upper, and in the other a member of the Lower, House put this question. I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.\n",
    "> _Passages from the Life of a Philosopher (1864), ch. 5 \"Difference Engine No. 1\"_\n",
    "\n",
    "Modern programmers call this: garbage in, garbage out. GIGO, for short."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "# Learning a (New) Language\n",
    "\n",
    "**_The single most important thing that you can learn is how to frame your problem in a way that you can communicate to a computer._** Crucially, the real power of the computer isn't figuring out how to tell it to add `1, 2, 3, 4` together and calculate the mean (average), it's figuring out how to tell it to add _any possible set of numbers_ together and work out the mean. It's when you start to see ways to do this for sets of _hard_ problems (for you) that you know you've started to understand the language. \n",
    "\n",
    "So these notebooks are intended to help you start learning a new language -- a programming language -- but you should always remember this: you're not stupid if you don't know how to explain things to the computer so that it can help you find the answer. You're learning the basics of how to communicate with computers; there are only two things that _are_ silly: the first is expecting to be able to run before you can walk; the second is copying and pasting answers without trying to understand _why_ they are answers.\n",
    "\n",
    "Actually, there is a third silly thing: not asking for help. In the same way that learning a new human language is easier if you immerse yourself in the culture and make friends with some native speakers, learning a new computer lanugage is easier if you immerse yourself in the culture of computing and make friends with some more proficient speakers. But just as your French- or Chinese-speaking friends will get tried of answering your questions if you don't make it obvious that you're working _hard_ to learn, most programmers won't be very impressed if you just ask for 'the answer' and then come back two days later with the _same question_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Mathematics is a Language, so is Code\n",
    "\n",
    "There are obviously many ways that you can calculate the mean (also known as the *average* if your maths is a little rusty): in your head, using pencil and paper, on a calculator, in Excel... and, of course, using code! For a small set of simple numbers, using your brain is going to be a lot faster than typing it into a calculator or computer.\n",
    "\n",
    "In the area immediately below this paragraph you should see something like \"<span style=\"color:blue\">In [ ]</span>\". On the right of this is an empty box into which you can type computer code (which we will call a 'code cell'). We can use Python like a calculator but doing it from a keyboard instead of a calculator's keypad. \n",
    "\n",
    "For example, to calculate 2 plus 2 using Python type `2 + 2` in the next code cell and run the code. \n",
    "\n",
    "*HINT*: To run, ensure your cursor is in the code cell and click the the 'Run' button in the toolbar above (the sideways-pointing triangle). Or, again with the cursor in the code cell, you can also type Ctrl+Enter on the keyboard (that's the Control button and the Enter button simultaneously)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If everything has gone well then you should see something like \"<span style=\"color:red\">Out [ ]</span>\" appear with the answer to the formula `2 + 2`. Hopefully it is `4`!\n",
    "\n",
    "That was an easy one; faster to calculate in our head than use Python. \n",
    "\n",
    "*But quick*, what's the average (mean) of: `1 + 2 + 3 + 4`?\n",
    "\n",
    "A little harder, huh? So let's use Python. \n",
    "\n",
    "Type your 'formula' to calculate the mean of `1, 2, 3, 4` in the code cell below, then click the 'Run' button on the tool bar at the top of the window to run your first piece of Python code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    },
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "*HINT*: Your equation should include the four numbers above with some `+` symbols and `(` and `)`, a `/` symbol, and another number.\n",
    "\n",
    "Did you get 2 or 2.5? \n",
    "\n",
    "*HINT*: If you are totally at a loss for what to type in the code cell, just click the \"show solution\" button below (if visible, if it's not you'll just see the answer we were looking for). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "(1 + 2 + 3 + 4) / 4 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    },
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "Even if you typed the equation incorrectly, you may not have obtained the 'correct' answer (in Python2 the result of `(1+2+3+4)/4` is `2`, whereas in Python3 the result is `2.5`). If you got the 'right' answer (`2.5`) then pat yourself on the back, but be warned that that was mostly luck because Python3 is trying to be helpful. If you got the 'wrong' answer that does **_not_** mean that you have done something wrong: computers do exactly what you tell them to do, and many of the problems you'll encounter in Code Camp and beyond are a result of the computer mindlessly and stupidly doing exactly what you told it to do, and not what you _meant_ for it to do!\n",
    "\n",
    "Or as some swag once put it:\n",
    "\n",
    "> Computers are tools for making very fast, accurate mistakes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "If you are using Python version 3 (which you _should_ be), you should have got the result `2.5`\n",
    "\n",
    "If you got the result `2`, you are using Python version 2 and will need to check (and change) your installation of Python (go back to the [Python Setup page](https://kingsgeocomputation.org/teaching/code-camp/code-camp-python/setup/), or try posting a query on Slack for help).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Silly is not stupid (learning languages is hard)\n",
    "\n",
    "This is really important: just because you told the computer to do something that you eventually realise was 'wrong' (you may even feel silly) **does _not_ mean that _you_ are stupid**. \n",
    "\n",
    "Did you ever try to learn a foreign language? Did you expect to be fluent after a couple of classes? Did you [accidentally tell your host that you were 'pregnant' when you were just 'embarrassed'](https://translate.google.com/#es/en/embarazada)? Assuming that you had a realistic expectation of how far you'd get with French, Chinese, or English in your first couple of years, then you probably figured it'd be a _while_ before you could hold a conversation with someone else. \n",
    "\n",
    "So why would you expect to sit down at a computer and be able to hold a conversation with it (which is another way of thinking about what coding is) after reading a few pages of text and watching a YouTube video or two? You will need to give it time, you will need to get used to looking at the documentation, you will need to ask for help (this seems like a good time to introduce [Stack Overflow](http://stackoverflow.com/)), and you will need to persevere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Practice makes perfect\n",
    "\n",
    "Your language class (assuming that you took one) probably had a 'lab' where you practised your new language and you probably made a lot of mistakes when you were getting started. It's the same for programming: the reason you got a 'silly' answer is that we haven't taught you how to ask the right question yet! For a language like Python \"`4`\" is not always the same as \"`4.0`\"... and sometimes the way ahead is unclear, but don't worry if you can't get the right answer _yet_, how to 'talk numbers' is the main topic in the _next_ notebook and we'll show you the answer at the end of this notebook.\n",
    "\n",
    "So, we want you to remember that there are no stupid questions when it comes to programming. We have _all_ been lost at one point or another! Your lecturers and instructors _frequently_ still ask for help (often by asking Google!), it's just that we do it for harder questions. And that's only because we have had a lot more practice in the language of programming. So the _only_ silly thing you can do in this course is to assume that you can speed through the questions and don't have to practice or think through the technical aspects of coding. \n",
    "\n",
    "We'll say it _again_: there's _one_ other silly thing that you can do, and that's not asking for help at all. If you've been banging your head against the computer for five or ten minutes trying to get something to work and it *just isn't working* then try explaining it to a friend or the instructor! Depending on the question we might: give you the answer and explain why it's the answer; give you a really annoying _partial_ answer because it's something that we want you to figure out for yourself; or say \"That's a really tough question, we'll have to look up the answer\". You never know until you ask.\n",
    "\n",
    "<img src=\"https://imgs.xkcd.com/comics/tasks.png\" width=\"350\" />\n",
    "\n",
    "There are web sites that will give you answers (in fact, we're going to point you to some of them) but if you don't expend any effort in trying to understand how the code works, or if you just copy the answer off of your friend, that's the same as assuming you'll learn a foreign language just because you're sitting next to a friend who is taking the same language course! _That_ is also silly.\n",
    "\n",
    "<span style=\"color:red;font-weight:bold;font-size:18pt;line-height: 24pt\">You will need to practice in order to progress. You don't learn French or Chinese by practising in the language lab once a week. You won't learn to program a computer by only practising during the practicals once a week.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### When computers beat brains (or calculators)\n",
    "\n",
    "What makes a computer potentially _better_ than a calculator (or your brain) is that a computer isn't daunted by having to count lots of numbers and it doesn't need you to input each number individually! The computer can also do things like: \n",
    "\n",
    "- find out the amount of rain that fell in London, Manchester, and Edinburgh yesterday from an online weather service;\n",
    "- work out the average rainfall for these three cities; and then \n",
    "- work out the standard deviation for rainfall.\n",
    "\n",
    "And it can do all of this in a matter of milliseconds! It can also do the same for 3,000 cities just as easily; sure, it'll take a little bit longer, but it's the *same basic code*. \n",
    "\n",
    "In other words, code is [scalable](https://en.wikipedia.org/wiki/Scalability) in a way that brains and calculators are not and that is a crucial difference.\n",
    "\n",
    "Here's a trivial example of when computers start to get better and faster than brains:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "outputs": [],
   "source": [
    "(23495.23 + 9238832.657 + 2 + 12921)/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remember*: click in the cell and then hit `Ctrl+Enter` to 'run' the cell and get the answer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "# Programming in Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Computer Languages\n",
    "\n",
    "In these notebooks we will be using the Python programming language. As with human languages, there are _many_ [programming languages](http://www.computerhope.com/jargon/p/proglang.htm) in the world, each with their own advantages and disadvantages, and each with their own vocabulary (allowed words) and grammar (syntax). We use Python. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### Python vs R\n",
    "\n",
    "Alongside Python, the other language that is often mentioned by people doing data-led research is [R](https://www.r-project.org). It's the _other_ one that many of your lecturers and a lot of other scientists use in a lot of their work.  There's [a great deal of debate about the relative merits of Python and R](https://www.quora.com/Which-is-better-for-data-analysis-R-or-Python), but for our purposes, _both_ Python and R can help us to undertake the geographical analysis. That is, in fact, the premise of this entire course! \n",
    "\n",
    "So why have we chosen to use Python here? Of the two languages, we think that Python has some specific advantages:\n",
    "\n",
    "1. It was designed for teaching, so its syntax is easier for a human to 'parse' than R's\n",
    "2. It is more _like_ other languages, so it is more readily transferrable if you need to learn another language. Think of it as learning Italian, which also makes it easier to learn Spanish and French.\n",
    "3. It is the one most-used as part of a *geographical workflow* – what we mean by this is that you can find Python buried inside of ESRI's ArcGIS and the open-source QGIS applications, and it also sits behind (or talks to) a number of other tools that allow us to work flexibly and scalably with geo-data. \n",
    "4. It is easier to operationalise – Python offers more services/tools to enable you to turn something from a 'hack' ([which doesn't mean what you think it means](https://en.wikipedia.org/wiki/Hacks_at_the_Massachusetts_Institute_of_Technology) into a 'service'.\n",
    "\n",
    "However, if you have been told R is the way to go then don't worry, the concepts covered here still translate. And many of the contributors to these notebooks use both languages... it just depends on the problem. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "### Python what?\n",
    "Python was invented by [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum) in the late 1980s and he continues in the role of 'benevolent dictator' to this day, which means that he (and some other very smart people) try to ensure that the language continues to meet the basic goals of:\n",
    "* Being very easy to read (syntax)\n",
    "* Using plain-English for many functions and operators (allowed words)\n",
    "* Has a comprehensive style guide: [PEP8](https://www.python.org/dev/peps/pep-0008/) (syntax)\n",
    "* Has no unnecessary special formatting characters (syntax _and_ allowed words)\n",
    "\n",
    "So while Python is not a language that enables the computer to make calculations the fastest (C and C++ are faster), nor is it the safest (you wouldn't use it to fly a rocket to Mars), it _is_ a very readable, learnable and maintainable language.\n",
    "\n",
    "So if you want to learn to code, to do 'data science', or build a business, Python is a great choice.\n",
    "\n",
    "The points above are also made in [Python In A Nutshell](http://mbrochh.github.io/python-101/#/6/1) by [Martin Brochhaus](https://github.com/mbrochh) which you may find interesting and useful to accompany your learning of Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": [
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)",
      "Michele Ferretti (https://github.com/miccferr)",
      "Jon Reades (https://github.com/jreades)",
      "James Millington (https://github.com/jamesdamillington)"
     ],
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "#### Three takes on Python\n",
    "The images below are links to three videos pitched in quite different ways at the advantages of Python, all of which touch on issues we'll be dealing with later... so watch the videos (even if they're a bit silly in places)!\n",
    "\n",
    "[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/aXKVOLwpDg8/0.jpg)](http://www.youtube.com/watch?v=aXKVOLwpDg8)\n",
    "\n",
    "[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/Hn4FbT4wMms/0.jpg)](http://www.youtube.com/watch?v=Hn4FbT4wMms)\n",
    "\n",
    "[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/G8brQdClo9s/0.jpg)](http://www.youtube.com/watch?v=G8brQdClo9s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computers: good or bad?\n",
    "\n",
    "What are computers good at?\n",
    "- Doing the same thing over and over\n",
    "- Doing _exactly_ what they are told to do\n",
    "\n",
    "What are computers currently still bad at?\n",
    "- Generating knowledge\n",
    "- Being creative\n",
    "\n",
    "There is a long-standing contest, called the Turing Test in honour of [the famous computer pioneer](https://en.wikipedia.org/wiki/Alan_Turing), that demonstrates this difference rather nicely: a computer passes the Turing test if it can fool a person into thinking that they're talking to another person. Some people have claimed that if a computer can _really_ pass the Turing Test by keeping up a conversation of indefinite length on any range of topics then we'll have to declare that machines have become full AIs (Artificial Intelligences). To put it another way: if it sounds like a human and responds like a human... then is it a human?\n",
    "\n",
    "Perhaps fortunately for us, although computers are getting a lot better at holding up their end of the conversation they still seem to have a hard time fooling anyone for very long. In contrast, bigger and better computers have now beat the best humans at Chess and Go, and are being used to help us understand earthquakes and climate change on a huge scale. Here, computers can do billions -- or trillions -- of calculations a second to work out that if 'A' happens then 'B' is the next most likely thing to happen, and so on and so on.\n",
    "\n",
    "The difference is that games like Go and Chess have well-understood rules as (ultimately) do natural processes like climate change and earthquakes. Chess is 'easier' for a computer than Go because a big enough computer can work out every possible chess move and pick the best one, whereas it can't do that for Go and so has to make 'choices' based on incomplete information. Earthquakes have even more 'rules', but as far we know they still follow _some_ set of rules dictated by physics and chemistry. \n",
    "\n",
    "People, however, don't use the same unchanging rules in conversation. Yes, conversations have norms, unless you're using an online comment forum where it's normal to start a conversation by asking someone if they're an idiot, but people don't just 'play games' within the rules, they actually play with the rules themselves in a way that computers find very, very hard to follow. Think of sarcasm: you say one thing but it means exactly the opposite. And if it's delivered deadpan then sometimes even people have trouble knowing if you're being sincere!\n",
    "\n",
    "That's why AI of the sort you might have seen in _2001_ or _Blade Runner_ has been twenty years away for the last sixty years! Recently, computers have been getting better and better at doing really difficult things, but it's usually still in a narrow area where we understand the rules and we normally need to spend a lot of time training the computer. \n",
    "\n",
    "#### More About the Turing Test\n",
    "Turing, A (1950), _Computing Machinery and Intelligence, Mind_ LIX (236): 433–460\n",
    "doi: [10.1093/mind/LIX.236.433](http://dx.doi.org/10.1093/mind/LIX.236.433), ISSN 0026-4423"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "geopyter": {
     "Contributors": "Jon Reades (https://github.com/jreades)",
     "git": {
      "active_branch": "master",
      "author.name": "Jon Reades",
      "authored_date": "2017-06-05 16:12:59",
      "committed_date": "2017-06-05 16:12:59",
      "committer.name": "Jon Reades",
      "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
     }
    }
   },
   "source": [
    "## Further Reading:\n",
    "\n",
    "- A **must** read: [The Hard Way is Easier](http://learnpythonthehardway.org/book/intro.html)\n",
    "- Two easy and accessible videos to start wrapping your head around programming (although they are not Python-centric) [1](https://www.youtube.com/watch?v=qUVWM2Q4vAU) and [2](https://www.youtube.com/watch?v=AImF__7FyzM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Credits!\n",
    "\n",
    "#### Contributors:\n",
    "The following individuals have contributed to these teaching materials: \n",
    "- [James Millington](https://github.com/jamesdamillington)\n",
    "- [Jon Reades](https://github.com/jreades)\n",
    "- [Michele Ferretti](https://github.com/miccferr)\n",
    "- [Zahratu Shabrina](https://github.com/zarashabrina)\n",
    "\n",
    "#### License\n",
    "The content and structure of this teaching project itself is licensed under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 license](https://creativecommons.org/licenses/by-nc-sa/4.0/), and the contributing source code is licensed under [The MIT License](https://opensource.org/licenses/mit-license.php).\n",
    "\n",
    "#### Acknowledgements:\n",
    "Supported by the [Royal Geographical Society](https://www.rgs.org/HomePage.htm) (with the Institute of British Geographers) with a Ray Y Gildea Jr Award.\n",
    "\n",
    "#### Potential Dependencies:\n",
    "This notebook may depend on the following libraries: None"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "geopyter": {
   "Contributors": [
    "Michele Ferretti (https://github.com/miccferr)",
    "Jon Reades (https://github.com/jreades)",
    "James Millington (https://github.com/jamesdamillington)"
   ],
   "git": {
    "active_branch": "master",
    "author.name": "Jon Reades",
    "authored_date": "2017-06-05 16:12:59",
    "committed_date": "2017-06-05 16:12:59",
    "committer.name": "Jon Reades",
    "sha": "2fce1fab4c3c28acabee493a24302e5ee1e8a1eb"
   },
   "libs": {}
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}