r_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fundamental concepts of programming for humanists (R)\n",
    "\n",
    "## Program flow\n",
    "Programming is the act of giving a series of instructions to the computer. Upon running the program, the computer then follows these instructions in sequence. Typically (but not always), each line in a program is a single instruction. \n",
    "\n",
    "The box below contains two instructions. Run them by selecting the box (by clicking on it) and pressing ctrl-enter (or selecting the play button from the menu above). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"Hello\")\n",
    "print(\"programming\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how two lines are printed. You can freely change the text inside the quotation marks to change what is printed. You can even add new print commands on additional lines. Try it!\n",
    "\n",
    "Naturally, a complete program will often be a lot more complex than this, but can often still be thought of as a sequence. For example, a program could: \n",
    " 1. read in the complete texts of an author\n",
    " 1. create a sheet counting how many times each distinct word appears in the texts (e.g. the: 50, world: 10, is: 30, suffering: 5)\n",
    " 1. read in the complete texts of another author\n",
    " 1. make a similar sheet of the words appearing therein\n",
    " 1. compare the counts between the two authors to produce two tables of:\n",
    "    1. the words appearing with most similar frequencies in both author's works\n",
    "    1. the words that appear with most dissimilar frequencies in the author's works\n",
    "\n",
    "## Variables\n",
    "\n",
    "As said, often in programs, you are doing something based on some data, and not just single items either, but e.g. the complete texts of a thousand books. And, you're going to do the same thing to multiple texts. And, the process is going to have multiple steps, with different representations for the data. Thus, you can't just copy and paste the text of those books inside print statements.\n",
    "\n",
    "Instead, you need a way for the program to refer to that data in a symbolic manner. For this, named variables can be defined In R, you put stuff in variables by `<-`, and retrieve it just by giving the variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "name <- \"Eetu\"\n",
    "# You can use =, but <- is more idiomatic R\n",
    "print(paste(\"Hello \", name, \".\",sep=\"\"))\n",
    "print(paste(\"Welcome to programming \",name,\".\",sep=\"\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we're storing in the variable just a simple piece of text. But in practice, variables can store much more interesting things, too (such as the complete works by an author as read from a text file, or the words counts derived thereof).\n",
    "\n",
    "In the above, also note how whitespace works. Inside program code itself, it doesn't matter if you have `a+b` or `a + b` or even `a +b`. On the other hand, inside the `\"` marks whitespace is important, because there it is data, not code. See below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [],
   "source": [
    "print(paste(\"Hello     \",name,\"     .\",sep=\"\"))\n",
    "print(paste(\"Hello\",     name,     \".\",sep=\"\"))\n",
    "print(paste(\"Hello\"   ,  name   ,  \".\",sep=\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "One way to act with values is by joining them with operators. In R, however, the `+` operator isn't defined for strings, so we have to use the `paste` method. A lot of the basic operators come from arithmetic and are mainly defined for numeric values, e.g. `+, -, /, *`. These also follow the precendence rules from basic math. Try them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( 1+5 )\n",
    "print( 1+5/2 )\n",
    "print( (1+5)/2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A second common class of operators are comparison operators, e.g.: `==, !=, >, <, >=, <=`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(paste(\"Is 1<5?\", 1<5 ))\n",
    "print(paste(\"Is 1>5?\", 1>5 ))\n",
    "print(paste(\"Is 1==5?\", 1==5 ))\n",
    "print(paste(\"Is 1!=5?\", 1!=5 ))\n",
    "print(paste(\"Is a<b?\", \"a\"<\"b\" ))\n",
    "print(paste(\"Is a==a?\", \"a\"==\"a\" ))\n",
    "print(paste(\"Is a!=a?\", \"a\"!=\"a\" ))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control flow\n",
    "\n",
    "A computer program isn't really just a sequence of commands. It can also contain control flow statements that affect how the computer proceeds through the program. These are where the above mentioned comparison operators most often are used. Try changing the name variable by changing the assignment in the cell above (and executing that cell), and see what happens when you after that execute the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if (name==\"John\") {\n",
    "    print(\"Hello Johnny\")\n",
    "} else if (name==\"Bruce Wayne\") {\n",
    "    print(\"Hello Batman\")\n",
    "} else\n",
    "    print(paste(\"Hello \",name,sep=\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That control flow construct was the `if` construct. Other important control flow constructs are `while` and its specialization `for`. They're used for doing stuff repeatedly (for example, to do something to all words in a sentence, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "count <- 1\n",
    "print(paste(\"Starting. Count: \",count))\n",
    "while (count <= 3) {\n",
    "    print(paste(\"In while, because count(\",count,\") just tested was below or equal to 3.\",sep=\"\"))\n",
    "    count <- count+1\n",
    "    print(paste(\"In while, about to test with new count:\",count))\n",
    "}\n",
    "print(paste(\"Done. Count (\",count,\") was not be below or equal to 3.\",sep=\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What the above does is: set the variable `count` to 1. Then, as long as `count` remains under 4, set `count` to `count + 1` and print information on it. \n",
    "\n",
    "Note that both the adding of 1 to `count` and the prints are included inside the while. That's because of the curly braces (`{}`). Try moving the last print statement current in the braces outside of it and re-running the cell. How did the output change? (Note that if you move `count=count+1`, the while will run forever)\n",
    "\n",
    "Below, the same repetition is done with the specialized for construct (repeating something for all values in a collection is such a frequent operation, it makes sense that most languages have a specialized construct for it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [],
   "source": [
    "print(\"Starting.\")\n",
    "for (i in 1:3) \n",
    "    print(paste(\"For: \",i,sep=\"\"))\n",
    "print(\"Done.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable types\n",
    "\n",
    "Notice, that in the above, R automatically converted the number `1` to the string `\"1\"`. However, this conversion only works one way, from numbers to strings. For example, the second statement in the following code just doesn't work. Try it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(10+10)\n",
    "print(\"10\"+10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "i <- 1\n",
    "print(paste(\"Type of i: \",typeof(i),sep=\"\"))\n",
    "j <- '1'\n",
    "print(paste(\"Type of j: \",typeof(j),sep=\"\"))\n",
    "print(paste(\"Is i equal to j?: \",i==j,sep=\"\"))\n",
    "print(paste(\"Is as.character(i) equal to j?: \",as.character(i)==j,sep=\"\"))\n",
    "print(paste(\"Is i equal to as.numeric(j)?: \",i==as.numeric(j),sep=\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here again, one has to note the important difference between R and python regarding conversions. In general, R does more automatic conversions between formats than Python, so in the above, the number 1 *is* actually equal to the string \"1\" even without explicit conversion!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# The computer understands how to convert the string 11 into a number \n",
    "as.numeric(\"11\")\n",
    "# Yet the string eleven isn't a number to the computer, even though it is to us.\n",
    "as.numeric(\"eleven\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's also an important difference. Where Python raised an error, R just issues a warning and returns NA (a special value denoting Not Available)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, the types of your variables in practice will often be much more complex than just strings or numbers (such as different particular ways of storing the texts of 1000 books). Still, converting data from one structure to another, as dictated by the needs of processing, is a big part of programming.\n",
    "\n",
    "## Functions/methods\n",
    "\n",
    "Often, one wants to also run a piece of code multiple times, from multiple parts of the program. For this, one *defines* functions, which work for code similarly to how variables work for storing and recalling values (except where data is often read in from outside the code, the logic for a function is specified inside its definition). Functions take in zero or more parameters (given in parentheses), and can optionally return back a single value.\n",
    "\n",
    "(In this way, they're also very much like mathematical functions, where e.g. `f(x)=x+2` is a function definition, with `x` as input and the body of the function defining the returned output as `x+2`.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# This is a function definition that takes in a single variable named string. It returns that string after some processing.\n",
    "standardize <- function(text) {\n",
    "  text <- gsub(\".\",\" \",text,fixed=TRUE)\n",
    "  text <- gsub(\",\",\" \",text,fixed=TRUE)\n",
    "  text <- gsub(\"?\",\" \",text,fixed=TRUE)\n",
    "  text <- gsub(\"!\",\" \",text,fixed=TRUE)\n",
    "  text <- gsub(\"'\",\"\",text,fixed=TRUE)\n",
    "  text <- tolower(text)\n",
    "  return(gsub(\"\\\\s+\",\" \",text))\n",
    "}\n",
    "\n",
    "print(standardize(\"Where are we? I don't know!\"))\n",
    "print(standardize(\"This, programming... is... terrifying!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very often, functions are packaged inside libraries, which you have to import in order to use. In R, the [`gsub`](https://www.rdocumentation.org/packages/base/topics/grep) and [`tolower`](https://www.rdocumentation.org/packages/base/topics/chartr) functions are in the [base library](https://www.rdocumentation.org/packages/base/), so nothing has to be imported here. However, libraries are still a big thing, and the syntax for importing them is `library(libraryname)`. Often, libraries contain both new functions as well as new data types. To use the library, one has to read up on both of them.\n",
    "\n",
    "Other functions we've also already seen are `as.character, as.numeric, typeof, paste` and also `print`!\n",
    "\n",
    "R doesn't really believe in object methods, so doesn't have any equivalent to the replace method of the Python string object. Instead, everything is just pure functions, and you need to pass the values as parameters ([digging deep](https://adv-r.hadley.nz/oo.html), R actually has multiple competing systems for supporting certain object oriented concepts. However, most of them don't look like the object methods in other languages, and in addition they're not broadly used).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data structures\n",
    "\n",
    "As said earlier, variables can hold much more complex data than just simple strings or numbers. They can in fact hold any data structure defined by the programming language or a libary. \n",
    "\n",
    "Most programming languages have two very useful core data types you should know. These are lists (or sequences or arrays) for holding multiple items, and dictionaries (or hashes or maps) for creating associations between items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# R doesn't have hash objects directly (but there is a hash package). However, pure R also does have vectors that may have named indices, so let's use that:\n",
    "replacements <- c(\n",
    "    \"\\\\.\" = \" \", \n",
    "    \",\" = \" \", \n",
    "    \"!\" = \" \",\n",
    "    \"\\\\?\" = \" \",\n",
    "    \"'\" = \"\",\n",
    "    '&' = \"and\"\n",
    ")\n",
    "\n",
    "standardize2 <- function(text) {\n",
    "    # Here we're going over all the keys in the replacement dictionary and acting on them\n",
    "    for (key in names(replacements)) {\n",
    "        text <- gsub(key,replacements[key],text)\n",
    "    }\n",
    "    return(gsub(\"\\\\s+\",\" \",tolower(text)))\n",
    "}\n",
    "\n",
    "# This is a list.\n",
    "sentences = c(\"Where are we? I don't know!\", \"This, programming... is... terrifying!\")\n",
    "\n",
    "# Here we're calling the function once for each string in the sentences list\n",
    "for (sentence in sentences)\n",
    "    print(standardize2(sentence))\n",
    "    \n",
    "# You can also explicitly refer to a particular slot in a list or a key in a dictionary using square brackets:\n",
    "print(replacements[\"&\"])\n",
    "print(sentences[1])\n",
    "# In R, indices start at 1!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Note that a dictionary can only contain one value for each key\n",
    "replacements2 <- c(\n",
    "    \".\" = \"?\", \n",
    "    \".\" = \"!\")\n",
    "print(replacements2[\".\"])\n",
    "\n",
    "# Therefore, if you need multiple values, you have to combine dictionaries with lists:\n",
    "replacements2 <- list(\".\" = c(\"?\",\"!\"))\n",
    "print(replacements2[\".\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an interesting albeit mostly useless note, see how in the above R returns \"?\" in the first instance, while Python returned \"!\". \n",
    "\n",
    "More usefully, note that in the above we couldn't use just simple vectors (created by `c()`, but instead had to use actual lists created by `list()`. The technical explanation here is that simple vectors are more efficient to the computer to process, but have the limitation of having to be flat, while actual lists can be more complex but are also therefore more expensive for the computer to operate upon. \n",
    "\n",
    "## Conclusion\n",
    "\n",
    "That's all I think you absolutely *need* to know in order to start reading and learning from examples. "
   ]
  }
 ],
 "metadata": {
  "kernel_info": {
   "name": "ir"
  },
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.5.0"
  },
  "nteract": {
   "version": "0.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}