wk1/MY470_wk1_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# What Is Computation?\n",
    "### Week 1 Lecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "* Computational thinking and algorithms\n",
    "* Computers, programming languages, and computer programs\n",
    "* Objects, expressions, and variables\n",
    "* Debugging\n",
    "* Version control with GitHub"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Computational Thinking\n",
    "\n",
    "\n",
    "> Computational Thinking is the thought processes involved in formulating a problem and expressing its solution in a way that a computer — human or machine — can effectively carry out.\n",
    "\n",
    "\n",
    "Wing, Jeannette M. (2006). [Computational thinking](http://tech-insider.org/academia/research/acrobat/0603.pdf). *Communications of the ACM*, 49(3), 33-35."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Defining Characteristics of Computational Thinking\n",
    "\n",
    "Wing, Jeannette M. (2006). [Computational thinking](http://tech-insider.org/academia/research/acrobat/0603.pdf). *Communications of the ACM*, 49(3), 33-35.\n",
    "\n",
    "* **Conceptualizing**, not programming — requires thinking at multiple levels of abstraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* A way that **humans**, not computers, think — requires cleverness and imagination"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Combines **mathematical and engineering** thinking — dictated by the constraints of physical computing devices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* For **everyone**, everywhere — just like reading, writing, and arithmetic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Algorithms\n",
    "\n",
    "An algorithm is a well-defined computational procedure that takes value(s) as input and produces value(s) as output.\n",
    "\n",
    "  * \"Recipe\" or \"instructions\" for solving a well-defined computational problem\n",
    "  * Consists of a sequence of simple steps, control flow, and a stopping rule\n",
    "  * Can be specified in human language or programming language (or even as hardware design)\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "For example, **a sorting algorithm**\n",
    "* Takes as input a sequence of numbers\n",
    "* Returns a permutaion (an ordering) of the input sequence such that successive numbers are larger or equal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Computers\n",
    "\n",
    "Computers automatically perform calculations, either built-in or user-defined, and store the results.\n",
    "\n",
    "![Computers](figs/computers.png \"Abacus, slide rule, Babbage's Difference Machine, ENIAC, Rasberry Pi\")\n",
    "\n",
    "(Image sources: Wikimedia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Programming Languages\n",
    "\n",
    "A programming language is a formal language used to specify a set of instructions for a computer to execute.\n",
    "\n",
    "* Primitive constructs\n",
    "* Syntax\n",
    "* Static semantics\n",
    "* Semantics "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Markup vs. Programming Languages\n",
    "\n",
    "\n",
    "|              | Markup Languages | Programming Languages   \n",
    "| :----------- |:---------------- | :----------------------\n",
    "|  |![Markup languages](figs/markup_lang.png \"Markup languages\") | ![Programming languages](figs/program_lang.png \"Programming languages\")\n",
    "| **Examples** | TeX, HTML, XML, **Markdown**   | C, Java, JavaScript, **Python**, **R**            \n",
    "| **Use**      | Structure and present data | Transform and generate data  \n",
    "| **Execution**| Program (e.g. a browser)   | Computer hardware \n",
    "| **Structure**| Inline tags    | Primitive constructs, syntax, static semantics, semantics \n",
    "\n",
    "(Image sources: Wikimedia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Primitive Constructs in Programming Languages\n",
    "\n",
    "* Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "470"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "470"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MY'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'MY'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Infix operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "156.66666666666666"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "470/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Syntax in Programming Languages\n",
    "\n",
    "* Rules for forming strings of characters and symbols\n",
    "* Programming languages have strict syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "470.5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "470 + 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-5-5a5b76bbe317>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-5-5a5b76bbe317>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    470 0.5\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "470 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Static Semantics in Programming Languages\n",
    "\n",
    "* Rules for forming meaningful syntactically valid strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-fb25aaf6edea>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'MY'\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m470\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "'MY'/470"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Semantics in Programming Languages\n",
    "\n",
    "* The meaning associated with a syntactically correct string that has no static semantic errors\n",
    "* Programming languages have simple semantics — statements have only one meaning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* **But this may not be the meaning the programmer had in mind!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types of Programming Languages\n",
    "\n",
    "* Low-level vs. high-level\n",
    "* General vs. application-targetted\n",
    "* Interpreted vs. compiled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Computer Program\n",
    "\n",
    "* A sequence of definitions and commands\n",
    "  * Commands (or \"statements\") instruct the computer to do something\n",
    "* For interpreted languages:\n",
    "  * Programs are executed by the language interpreter (or \"shell\")\n",
    "  * They can be typed directly in the shell \n",
    "  * Or they can be stored in a file and run from the shell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objects, Data Types, and Expressions\n",
    "\n",
    "* Programs manipulate objects\n",
    "* Objects have types\n",
    "  * Scalar — indivisible\n",
    "  * Non-scalar — with internal structure\n",
    "* Expressions combine objects and operators\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# scalar objects\n",
    "2\n",
    "0.125\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# non-scalar objects\n",
    "'This is a string.'\n",
    "[1, 2, 3, 'a', 'x']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# expressions\n",
    "2/0.125\n",
    "'MY' + '470'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables\n",
    "\n",
    "* Variables associate objects with a name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 3.14\n",
    "b = 11.2\n",
    "c = a*(b**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pi = 3.14\n",
    "diameter = 11.2\n",
    "area = pi*(diameter**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* 📖 **Variable names help humans read programs!** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* 📖 **Comments also improve legibility!** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "pi = 3.14\n",
    "diameter = 11.2 # diameter of circle\n",
    "area = pi*((diameter/2)**2) # estimate area of circle using diameter "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Computer Bugs\n",
    "\n",
    "![Computer Bug](figs/bug.jpg \"Computer Bug\")\n",
    "\n",
    "The actual first computer bug. On September 9, 1947, Admiral Grace Hopper found this moth trapped on a relay of the Harvard Mark II computer. (Image source: U.S. Naval Historical Center Online Library)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What Is Computer Programming Really about?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "*99 little bugs in the code,*\n",
    "\n",
    "*99 bugs in the code,*\n",
    "\n",
    "*1 bug fixed...run again,*\n",
    "\n",
    "*100 little bugs in the code...*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How to Debug: Two Options\n",
    "\n",
    "1. **Google** the error and find an answer on **Stackoverflow**\n",
    "1. Use **`print()`** systematically"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The `print` Function in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The\n",
      "The winning number is 7 .\n",
      "The winning number is 7.\n"
     ]
    }
   ],
   "source": [
    "print('The')\n",
    "print('The', 'winning', 'number', 'is', 7, '.')\n",
    "print('The winning number is '+ str(7) + '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Debugging Systematically\n",
    "\n",
    "1. Compare input in successful and failing runs\n",
    "* Formulate a hypothesis\n",
    "* Design an experiment to test the hypothesis; use `print()`\n",
    "* Keep record of your experiment\n",
    "* Repeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## After Debugging for Hours...\n",
    "\n",
    "* Stop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Try commenting your code or explaining it to someone else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Sleep on it\n",
    "\n",
    "![Best Debugger](figs/debugging_sleep.png \"Best debugger\")\n",
    "\n",
    "(Image source: Reddit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Version Control with GitHub\n",
    "\n",
    "![GutHub Octocat](figs/Octocat.jpg \"GutHub Octocat\")\n",
    "\n",
    "* Code hosting platform for version control and collaboration\n",
    "* Based on Git\n",
    "  * Version control system for tracking changes in computer files and coordinating work on those files among multiple people\n",
    "  * Created in 2005 by Linus Torvalds\n",
    "* Largest host of source code in the world\n",
    "* Bought by Microsoft in 2018"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## GitHub Lingo\n",
    "\n",
    "* Repository – a space for a project/assignment\n",
    "* Clone – a copy of the repository that lives on your computer\n",
    "* Branch – a paralel version of the repository\n",
    "* Commit – save changes with a short description\n",
    "* Pull request – ask changes to be merged\n",
    "* Merge – incorporate changes (then delete branch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## GitHub Workflow\n",
    "\n",
    "![GutHub Workflow](figs/github.jpg \"GutHub Workflow\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## GitHub Workflow in MY470\n",
    "\n",
    "![GutHub Workflow in MY470](figs/github-class.jpg \"GutHub Workflow in MY470\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Getting Started with GitHub\n",
    "\n",
    "* Create personal account on https://github.com/\n",
    "* Go to https://education.github.com/ and get the Student Developer Pack for some cool freebies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Three ways to interact\n",
    "  1. Browser (covered in lab)\n",
    "  2. Command line (covered in lab) \n",
    "  3. GitHub Desktop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Terminal = Console = Shell = Command Line = Command Prompt\n",
    "\n",
    "(for our purposes here)\n",
    "\n",
    "![Terminal](figs/terminal.png \"Terminal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## First Things First\n",
    "\n",
    "![Vim problems](figs/vim.jpg \"Vim problems\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Change Your Default Text Editor for Git\n",
    "\n",
    "You can use your favorite editor by customizing the Git default editor.\n",
    "\n",
    "For example, you can use [**Nano**](https://www.nano-editor.org/). It is much easier to use than Vim: `Ctrl+o` to save and `Ctrl+x` to close.\n",
    "\n",
    "To set Nano as the default editor for your commit messages, run the following:\n",
    "\n",
    "```\n",
    "git config --global core.editor \"nano\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Nano comes pre-installed with Linux and OS. For Windows, download and install [**Nano-win**](https://github.com/mcandre/nano-win)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Important Git Commands \n",
    "\n",
    "* Copy online repository\n",
    "```\n",
    "git clone https://github.com/lse-my470/lectures.git\n",
    "```\n",
    "* Update local repository\n",
    "```\n",
    "git pull\n",
    "```\n",
    "* See the status of local respository\n",
    "```\n",
    "git status\n",
    "```\n",
    "* See the change history of local respository\n",
    "```\n",
    "git log\n",
    "```\n",
    "* Stage all changes\n",
    "```\n",
    "git add --all\n",
    "```\n",
    "* Commit staged changes\n",
    "```\n",
    "git commit\n",
    "# or \n",
    "git commit -m \"your commit message here\"\n",
    "```\n",
    "* Upload your changes to online repository\n",
    "```\n",
    "git push\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Resources\n",
    "\n",
    "* Get started: [GitHub tutorials](https://guides.github.com/)\n",
    "* Get it done: [Git cheatsheet](https://services.github.com/on-demand/downloads/github-git-cheat-sheet.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What Is Computation?\n",
    "\n",
    "We use programming languages to write programs that instruct computers to perform algorithms, which calculate results or process data.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "-------\n",
    "\n",
    "* **Lab**: Installing Anaconda, working with Jupyter, and uploading assignments on GitHub\n",
    "* **Problem set (FORMATIVE)**: Due at 12:00 on Monday\n",
    "* **Next week**: Data types in Python"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}