Rintro_part4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "5dfbae6f-24af-46d8-947b-c870ba21cbf7",
    "_uuid": "bb7243bbb4e9b8dadbcfb16e8783c802edbe64fa"
   },
   "source": [
    "![](https://www.r-project.org/Rlogo.png)\n",
    "\n",
    "____________________________________________________________________________________\n",
    "This tutorial is the fourth part of a series. You can start with the first part of the tutorial [here](https://www.kaggle.com/rtatman/getting-started-in-r-first-steps/).\n",
    "\n",
    "In this part of the tutorial, we'll:\n",
    "* learn how to graph our data\n",
    "* save our graphs\n",
    "\n",
    "____________________________________________________________________________________\n",
    "\n",
    "\n",
    "### Learning goals:\n",
    "\n",
    "By the end of this tutorial, you will be able to do the following things. (Don't worry if you don't know what all these things are yet; we'll get there together!)\n",
    "\n",
    "* [Be familiar with basic concepts: functions, variables, data types and vectors](https://www.kaggle.com/rtatman/getting-started-in-r-first-steps/)\n",
    "* [Load data into R](https://www.kaggle.com/rtatman/getting-started-in-r-load-data-into-r)\n",
    "* [Summerize your data](https://www.kaggle.com/rtatman/getting-started-in-r-summarize-data)\n",
    "* [Graph data and save your graphs](https://www.kaggle.com/rtatman/getting-started-in-r-graphing-data/)\n",
    "\n",
    "______\n",
    "\n",
    "### Your turn!\n",
    "\n",
    "Throughout this tutorial, you'll have lots of opportunities to practice what you've just learned. Look for the phrase \"your turn!\" to find these exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "b3e64ed4-fc40-462a-bc39-4cbbc2271eb2",
    "_uuid": "3e1abd0ea65a84f99d3c24501a9c3961d403b0dd"
   },
   "source": [
    "> **This notebook is interactive! It will have errors until you fork it and add all the code it needs to run correctly. Don't worry: if you've been working through this tutorial you already know everything you need to get it working correctly and I'll give you instructions and reminders to help you out.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "a395a9f0-372a-4419-a992-45a3c3e0bc0f",
    "_uuid": "a21abed1aaddcbde1a257630e39ee49b84d07817"
   },
   "source": [
    "## Review: Load in and clean our data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "ba7605d6-f039-4533-8a63-758ced26fb39",
    "_uuid": "85657a8c970386e28f38234668b6b27e9f0bf6f3"
   },
   "source": [
    "You might remember from [the last part of this tutorial](https://www.kaggle.com/rtatman/getting-started-in-r-summarize-data) that when you start a new notebook or R session R forgets everything you told it before. So, before we can get started on graphing our data we're going to have to :\n",
    "\n",
    "* Tell R what libraries we're going to use\n",
    "* Load our data in\n",
    "* Clean our data again\n",
    "\n",
    "In the cell below, follow the directions in the comments (lines beginning with the hashtag or pound symbol (#)) to get our data good to go. Try to test yourself by doing it without looking back at the last lesson first, although if you can't remember a step you can of course take a peek back at the last part to remind yourself.\n",
    "\n",
    "> Hint: Make sure you're assigning your data_frame to the variable name \"chocolateData\" at each step. This overwrites what was previously in the data_frame with your corrected version. You'll be able to tell that you've forgotten to do this because the whole data_frame will print out in your output!\n",
    "\n",
    "I've done some of the steps that we didn't talk about in a lot of detail for you, but if you try to run the cell without filling the rest of it in first, you're going to get an error message!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "9c534969-453f-4e78-b545-d06600e1fd94",
    "_uuid": "79afe21fc8fe7dfc42cf19e991e0de30c2c7d327",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in gsub(\"[[:space:]+]\", \"_\", names(chocolateData)): object 'chocolateData' not found\n",
     "output_type": "error",
     "traceback": [
      "Error in gsub(\"[[:space:]+]\", \"_\", names(chocolateData)): object 'chocolateData' not found\nTraceback:\n",
      "1. gsub(\"[[:space:]+]\", \"_\", names(chocolateData))"
     ]
    }
   ],
   "source": [
    "# Your turn!\n",
    "\n",
    "# tell R that we're going to use the tidyverse library\n",
    "\n",
    "# read in our dataset as a data_frame and save it as a variable named \"chocolateData\"\n",
    "\n",
    "# remove the first line of our dataset using a negative index\n",
    "\n",
    "# remove the white spaces in the column names\n",
    "names(chocolateData) <- gsub(\"[[:space:]+]\", \"_\", names(chocolateData))\n",
    "\n",
    "# remove percentage signs in the Cocoa_Percent \n",
    "chocolateData$Cocoa_Percent <- sapply(chocolateData$Cocoa_Percent, function(x) gsub(\"%\", \"\", x))\n",
    "\n",
    "# automatically try to guess the data type of each column using type_convert\n",
    "    \n",
    "# check the first few lines of our data_frame to make sure everything looks alright.\n",
    "# Do you remember which function we've been using to do this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "ad4caa61-1a11-44bb-97de-fce339dbefc6",
    "_uuid": "31ac82abc6fd57c665481c290bdfda0c0423a634"
   },
   "source": [
    "## Graph our data with ggplot2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "21cc4ce6-e5c8-43c6-960d-4e0fd1a3384d",
    "_uuid": "591d2aca4d10a849d96f5647914da2d79614b59d"
   },
   "source": [
    "Alright, now we've got our data and it's ready and clean! Time to make some graphs. To do this, we're going to use a library called \"ggplot2\", which is part of the tidyverse collection of packages. (Which means, since we've already imported the \"tidyverse\" library, we don't have to do anything else to start using it.)\n",
    "\n",
    "> The \"gg\" in \"ggplot\" stands for \"the grammar of graphics\". If you're curious, you can learn more about what this means in [this paper](http://vita.had.co.nz/papers/layered-grammar.html).\n",
    "\n",
    "Plots in ggplot2 are \"built up\" using multiple functions connected with the plus sign (+). The first function, ggplot(), just draws the outline of the plot, including the the axes and tick marks. It takes two arguments.\n",
    "1. The dataset that you want to plot. \n",
    "2. A function, aes(), short for aesthetic. This function itself takes multiple arguments. Let's start by using x & y, which will tell the function which columns of the data_frame to plot on the x axis and y axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "db6d266a-10bb-49dc-8c47-b7a785d0c6d7",
    "_uuid": "57eb44d88c2614f97d347645d45e8fe2bf2b3c1c",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\n",
     "output_type": "error",
     "traceback": [
      "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# draw a blank plot with \"Review_Date\" as the x axis and \"Rating\" as the y axis.\n",
    "ggplot(chocolateData, aes(x= Review_Date, y = Rating))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "0bcf8b62-3650-4d79-b84c-855afcc26692",
    "_uuid": "fdb6f3bea9c8865d728fbda75f045eefd209c5ee"
   },
   "source": [
    "As you can see, the ggplot() function doesn't actually plot anything. To do this, we need to add a geom layer to our plot. There are lots of different geom layers (you can see a full list of them [here](http://ggplot2.tidyverse.org/reference/#section-layer-geoms)) and you can add multiple layers to the same plot.\n",
    "\n",
    "> **Hint**: Different geoms require different aesthetics. If your code runs but doesn't return a plot, it's usually because you've given ggplot() one set of aesthetics, but the geom you're using need a different set. geom_histogram(), for example, only needs to  know what to plot on the x axis. If you tell it to plot something on the x axis and something else on the y axis, it won't return the plot you're expecting.\n",
    "\n",
    "For now, let's start by adding points to our plot, one for each data point. You may know this as a \"scatter plot\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "81ee8e95-8c6b-48ab-9b0f-f2d8de0412fc",
    "_uuid": "7cef0d0b37d8973e901dae8962969ccc8620d004",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\n",
     "output_type": "error",
     "traceback": [
      "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# draw a plot with \"Review_Date\" as the x axis and \"Rating\" as the y axis, and add a point for each data point\n",
    "ggplot(chocolateData, aes(x= Review_Date, y = Rating)) + geom_point()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "b90eedcc-50bb-4ae2-b6b1-4e8584b58dbb",
    "_uuid": "02de62a381380965666388efa87523ad66bbf742"
   },
   "source": [
    "So our plot rendered correctly, but it looks like we're running into a problem: a lot of our data points are being plotted on top of each other. This makes our plot very difficult to read. There is an easy way to fix this, however: we can move each point just a little bit so we can actually see how many of them there are. We can do this using the geom \"jitter\", which we add by adding the layer geom_jitter()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "_cell_guid": "8e55a3fe-3759-4976-8e69-2f1ff03e3709",
    "_uuid": "990a9842e178c2cab2529ab15ff8e6dc00fab039",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\n",
     "output_type": "error",
     "traceback": [
      "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# draw a plot with \"Review_Date\" as the x axis and \"Rating\" as the y axis, add a point for each data point & move each point slightly so they don't overlap\n",
    "ggplot(chocolateData, aes(x= Review_Date, y = Rating)) + geom_point() + geom_jitter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "2be2300d-66e6-42b9-b034-1968c4f72aba",
    "_uuid": "9f110dc77af888d32fe9fda0cdfde470eec69bb8"
   },
   "source": [
    "There we go, that plot is much easier to read! We can see that there seem to be more reviews each year, and that they seem to be getting more tightly clustered. \n",
    "\n",
    "What about our question from the last part of the tutorial: are reviews getting more positive over time? One way to check this is to fit a linear model to this data and see if it goes up or down over time. Using ggplot2, this is very easy to do! We can add a layer that will fit a linear model to this dataset and then plot it. Like so: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_cell_guid": "27e49ca8-e53b-42f6-9615-4cab7c0f8615",
    "_uuid": "c0ec2d1d886043b9fd20ea5b3fd87ee9700ad5e8",
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\n",
     "output_type": "error",
     "traceback": [
      "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating)): could not find function \"ggplot\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# draw a plot with \"Review_Date\" as the x axis and \"Rating\" as the y axis, add a point for each data point, move each point slightly so they don't overlap and add a smoothed line (lm = linear model)\n",
    "ggplot(chocolateData, aes(x= Review_Date, y = Rating)) + \n",
    "    geom_point() + \n",
    "    geom_jitter() +\n",
    "    geom_smooth(method = 'lm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "b4336a41-7b46-4269-b8d5-76fb3ea34894",
    "_uuid": "63aac34d4451962dd42dfe0aa95faf4045f62ae9"
   },
   "source": [
    "You can keep adding additional information to plots very easily by adding additional layers and aesthetic mappings. For instance, we might want to see how the cocoa percentage of chocolate bars change over time and how that affects ratings. We can do this by adding another argument to the aes() function, and telling it to plot the column Cocoa_Percent to color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "_cell_guid": "81616f83-eaec-44ea-8e2a-c136cf95643a",
    "_uuid": "5f9909872bc50c1d8483fe3aae344d3f533d7629",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating, color = Cocoa_Percent)): could not find function \"ggplot\"\n",
     "output_type": "error",
     "traceback": [
      "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating, color = Cocoa_Percent)): could not find function \"ggplot\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# draw a plot with \"Review_Date\" as the x axis and \"Rating\" as the y axis, add a point for each data point, move each point slightly so they don't overlap and add a smoothed line (lm = linear model). Encode Cocoa_Percent as color.\n",
    "ggplot(chocolateData, aes(x= Review_Date, y = Rating, color = Cocoa_Percent)) + \n",
    "    geom_point() + \n",
    "    geom_jitter() +\n",
    "    geom_smooth(method = 'lm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "2108dd6e-61d1-429f-9c70-209e36de0adc",
    "_uuid": "e1dcf0da3468c2a7901496bd68aba0ba2bdcf12f"
   },
   "source": [
    "It looks like chocolate bars with very high cocoa percents tend to get lower ratings. Let's see if that's the case by drawing a helpful graph. At this point, you know enough to make this graph yourself. Show me what you got! :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_cell_guid": "0907ef6f-1b62-4e6b-b25e-51cbf57e480b",
    "_uuid": "4ab98fa4f33da0042b9ac020e0a4c7423d85fd0c",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Plot the relationship between cocoa percentage and ratings, using whichever geom (or multiple geoms) you like.\n",
    "\n",
    "# Note that, if you use geom_smooth(), a linear model may not be the best fit for the data!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "4226fcc6-4596-4dd0-a253-d6341df76375",
    "_uuid": "e9b65243d1d54db5c89188c91b77b362100bada4"
   },
   "source": [
    "## Save our graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "73049f2e-0a82-40df-b96d-c792df642a9d",
    "_uuid": "fed2bfa31555fc40008ad3952e78837596519ef6"
   },
   "source": [
    "Excellent, we've got some pretty graphs and we want to show them off! But... how do we do that? We actually have a couple of options. \n",
    "\n",
    "One way is to **share the whole notebook**. To do this, you need to do two things. The first is to set the notebook to \"public\" using the dropdown menu at the top of the screen. (All Kaggle notebooks are private by default.)\n",
    "\n",
    "![](https://image.ibb.co/jq36e5/Screenshot_from_2017_08_30_12_14_36.png) \n",
    "\n",
    "The second is to hit the blue publish button. This will run all the code chunks in a notebook and then make a static version available.\n",
    "\n",
    "> Protip: When you publish a notebook it will run all the code chunks in a new session. This means that if, for example, you've imported a library in your current session and then deleted the library() call you'll get errors in your published notebook when you try to use functions from that library. You can check your notebook before you hit publish by closing and opening it again and running each code chunk in order.\n",
    "\n",
    "Another way to is **save individual files**. This is useful if you want to share just a single figure or datafile without all the code you use to make it. We can save the output of ggplot() using the handy ggsave() function, like this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_cell_guid": "e52c3476-fec0-4da5-83c4-08be84c45cf4",
    "_uuid": "769fb1938ad49f1a76c24c2962a9fb8e506c6197",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating, color = Cocoa_Percent)): could not find function \"ggplot\"\n",
     "output_type": "error",
     "traceback": [
      "Error in ggplot(chocolateData, aes(x = Review_Date, y = Rating, color = Cocoa_Percent)): could not find function \"ggplot\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# save our plot to a variable with an informative name\n",
    "chocolateRatingByReviewDate <- ggplot(chocolateData, aes(x= Review_Date, y = Rating, color = Cocoa_Percent)) + \n",
    "    geom_point() + \n",
    "    geom_jitter() +\n",
    "    geom_smooth(method = 'lm')\n",
    "\n",
    "# save our plot\n",
    "ggsave(\"chocolateRatingByReviewDate.png\", # the name of the file where it will be save\n",
    "       plot = chocolateRatingByReviewDate, # what plot to save\n",
    "       height=6, width=10, units=\"in\") # the size of the plot & units of the size\n",
    "\n",
    "# notice that this cell doesn't have any output in place! That's because in the first section we're \n",
    "# giving the plot a name rather than printing it, and in the second we're saving our plot rather \n",
    "# than printing it. We've never actually said to print our plot at any point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "030f910f-51db-4e58-afa2-81d1ed086d9c",
    "_uuid": "3c1635ccc8fbd8182aa8a10ec563268434463b45"
   },
   "source": [
    "\n",
    "Once you've run this code chunk, your files are saved as a kernel's output. You can get the output from the output tab at the top of the notebook, which shows up between the \"Data\" and \"Comment\" tabs on notebooks that have output. \n",
    "\n",
    "![](https://image.ibb.co/mHG3Rk/Screenshot_from_2017_08_30_12_44_51.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_cell_guid": "a6ad72e4-8b9c-4dca-8d21-4acb72494b5c",
    "_uuid": "3b3b8bf6536dd1d9e6852542da378fdc5959d772",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Save the plot you made showing the relationship between cocoa percentage and to this kernel's output. \n",
    "\n",
    "# Extra credit: I'd love it if you tweeted your plot to me! I'm @rctatman on Twitter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "d28f7f38-4c00-4bdf-9e0f-d5aa0cbd5af0",
    "_uuid": "88ed303301940a046636cd89bd7d731df0385d20"
   },
   "source": [
    "And that's it for this tutorial! You've got all the tools you need to start analyzing and plotting data on your own. I'm so excited for you to start your R journey. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "caa8a5d0-d411-4f15-93ce-3bb6ac2a8c30",
    "_uuid": "d0f616d79ba43a418d4e4170f670f8cc93800b11"
   },
   "source": [
    "## Putting it together: Summary graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "16888a7a-365c-4ead-a8e9-caa23dfb4dbb",
    "_uuid": "30d403099a68052ef9b1bf93a6d9a9788489450a"
   },
   "source": [
    "In the last part of this tutorial we learned about pipes (%>%) and how we could use them to group and summarize data, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_cell_guid": "1356d47e-bd86-4f15-ac53-8378e936880e",
    "_uuid": "cba906bbccf74786ce396f97d5a48b6b3f571f1a",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in chocolateData %>% group_by(Review_Date) %>% summarise(averageRating = mean(Rating), : could not find function \"%>%\"\n",
     "output_type": "error",
     "traceback": [
      "Error in chocolateData %>% group_by(Review_Date) %>% summarise(averageRating = mean(Rating), : could not find function \"%>%\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# Return the average and sd of ratings by the year a rating was given\n",
    "chocolateData %>%\n",
    "    group_by(Review_Date) %>%\n",
    "    summarise(averageRating = mean(Rating),\n",
    "             sdRating = sd(Rating))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "bd39acf5-e6c7-46fe-b399-8a95a05a264e",
    "_uuid": "d7aef0fb97a4f718de0c576cb18c004e5e1fbcf9"
   },
   "source": [
    "We can then plot these summarized datasets, which may give us a better idea of trends than plotting the entire dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "_cell_guid": "535ee61e-d067-4a93-b50b-72755f4f6946",
    "_uuid": "130f3672def6c12ef806b2fc7aeb681e819320ab",
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in chocolateData %>% group_by(Review_Date) %>% summarise(averageRating = mean(Rating)): could not find function \"%>%\"\n",
     "output_type": "error",
     "traceback": [
      "Error in chocolateData %>% group_by(Review_Date) %>% summarise(averageRating = mean(Rating)): could not find function \"%>%\"\nTraceback:\n"
     ]
    }
   ],
   "source": [
    "# Return the average and sd of ratings by the year a rating was given\n",
    "averageRatingByYear <- chocolateData %>%\n",
    "    group_by(Review_Date) %>%\n",
    "    summarise(averageRating = mean(Rating))\n",
    "\n",
    "# plot only the average rating by year\n",
    "ggplot(averageRatingByYear, aes(y= averageRating, x = Review_Date )) + \n",
    "    geom_point() + # plot individual points\n",
    "    geom_line() # plot line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "_cell_guid": "9826b3c9-6900-4ac9-9d52-7cc338d53298",
    "_uuid": "dc5d31d085e8b2aff7f69c78ab1e64af35f13bb7",
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your turn!\n",
    "\n",
    "# Make & save a data_frame with the average and sd Cocoa_Percent by the year the reviews were written\n",
    "\n",
    "# Plot the data_frame you've made using your choice of geom(s)\n",
    "\n",
    "# Save your plot to the output\n",
    "\n",
    "# Extra credit: Add a title to your plot. You may find the function ggtitle() helpful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "bcded4a0-c73f-49fb-8780-312f9090bf36",
    "_uuid": "ea2220f9eaed94b7773bd635a2153f615396b89e"
   },
   "source": [
    "## Next step: [Find an interesting dataset and start a new analysis!](https://www.kaggle.com/datasets?sortBy=updated&group=featured)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "bdeefb52-06f5-4e2e-8325-0769a5a463c9",
    "_uuid": "e116995dbd6a3078234b32675c454b07fa9ed086"
   },
   "source": [
    "--------------------------------------------------------------\n",
    "## Some parting thoughts: \n",
    "\n",
    "As you get more comfortable with R, you're probably going to want to explore this programming language more. Below, I've collected some resources you might find helpful, and some handy tips that I've found valuable. Good luck and have fun!\n",
    "\n",
    "--------------------------------------------------------------\n",
    "\n",
    "### A few resources:\n",
    "\n",
    "* The tidyverse documentation can be found here: http://www.tidyverse.org/\n",
    "* I've found these books to be very helpful and clearly written. (And also very free, which doesn't hurt!). They've by Hadley Wickham, who designed and wrote many of the tidyverse packages, including ggplot:\n",
    "  * [R for Data Science](http://r4ds.had.co.nz/)\n",
    "  * [Ggplot2: Elegant Graphics for Data Analysis](http://ggplot2.org/book/)\n",
    "  * [Advanced R](http://adv-r.had.co.nz/)\n",
    "* If you're interested in text analysis or Natural Language Processing, I would recommend the excellent tidytext package. The book is available for free [here](http://tidytextmining.com/).\n",
    "* If you'd like to work with R locally on your personal computer, I would recommend using the [RStudio](https://www.rstudio.com/) integrated development environment. You can work with R in your command line/console, but RStudio is like a word-processor program for code. It has a lot of nice features that make it nicer and simpler to write R code.\n",
    "* The R community is very active and welcoming. [This blog post](http://www.burns-stat.com/r-and-social-media/) has a good overview of places you can look to find help (and new friends!). \n",
    "\n",
    "--------------------------------------------------------------\n",
    "\n",
    "### Some handy tips:\n",
    "\n",
    "1.  If you get an error message you can't figure out, **copy the text of the error and Google it** to see if anyone else has had the same problem. 99 times out of 100 you'll find that someone else has already come up with a solution!\n",
    "2.  **Double-check your capitalization**. I find that a good 20% of my errors are because I've mis-capitalized something.\n",
    "3.  **Read the documentation**! Remember that you can quickly pull up the documentation for a certain function by putting a question mark in front of the function name and then running the command. \n",
    "4. If you're not sure how to start approaching a problem, **start by writing out all the steps you want your code to do in English** (or your language of choice). Then turn each step into a separate comment in your code and write the code to do that step underneath it. Not only will it help you organize your thoughts, but your code will also be nicely commented when you're done.\n",
    "5. Remember that you put the arguments for a function in parentheses (), and you get data from inside an object using square brackets []. **someText() is a function, someText[] is an object**: if you try to pass arguments to an object you'll get an error.\n",
    "6. If you're not sure why a data_frame isn't acting the way you expect it to, **str() is a good place to start figuring out what an object is behaving in a surprising way**. You'd be surprised how often I've found out that what I thought was a data_frame ended up being something else entirely!\n",
    "7. **Remember not to put special characters in names**. In general, the only non alpha-numeric character you want to use in a name is a period (.) or underscore (\\_) between words to make it easier to read. You can find a handy style-guide [here](http://adv-r.had.co.nz/Style.html). (You don't have to follow a style-guide, but it makes it easier for other people to read your code.)\n",
    "8. **You can keep certain lines of code from running but putting a hashtag/pound sign (#) in front of them** to turn them into comments. This is called \"commenting out\" code, and it can be really helpful if you're trying to figure out which lines are generating which errors.\n",
    "9. Once you start typing a part of R code, like the name of a variable or a function, **you can complete words in your code automatically by pressing the TAB key**. If there's more than one valid completion, a list of possible completions will drop down. This is really handy when you want to see all your geom options, for example.\n",
    "10.  **Read other people's R code**. I've learned a lot of handy tips over the years from seeing how other people do things. On Kaggle, you can find R code by going to [the kernels page](https://www.kaggle.com/kernels) and filtering for kernels written in R.  \n",
    "\n",
    "![](https://image.ibb.co/cRsYcQ/Screenshot_from_2017_08_30_13_49_23.png)"
   ]
  }
 ],
 "metadata": {
  "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.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}