Getting started with R and RStudio

This display, by the way, was created with an R package called Shiny. We’ll get to building interactive websites (like this one) and documents later on in the series.

Figure 1: R Project main page

Figure 2: Available mirror sites to download R

Figure 3: Operating system selection

Figure 4: Download the most recent .pkg file

You can download the .pkg file to any folder on your hard drive. After running this installation file, accept the prompt to move this file to the trash. You will not need it again.

Figure 5: Run the .pkg file to install R on your machine.

Figure 6: View the default software installed with the R .pkg installer.

Figure 7: List of software installed on your machine as part of the installation process.

Figure 8: A view of the default R Application GUI.

Figure 9: Running 1 + 1 at the prompt in the R Application.

Figure 10: RStudio homepage.

Figure 11: List of R Studio versions.

Figure 12: List of R Studio installers for various operating systems.

Figure 13: First look at RStudio.

RStudio Panes

The layout of RStudio includes four main ‘panes’: Console, Editor, Files, and the Environment panes. You already are familiar with the idea of the console, seen here in Figure 14. Remember that this is the area that is a direct line between the IDE and the R interpreter. When RStudio is first launched, it will start an R session and this has the effect of reporting some details about the version of R that you are running and the operating system that it is running on.

Figure 14: RStudio “Console” pane.

The next logical pane to introduce is the Editor pane, seen in Figure 15. Whereas commands written in the console are run on a line by line basis interactively, the Editor will be a useful space for us to view, edit, and write R scripts, as well as other files. Scripts are simply files that contain a series of R commands that we can then run together at once, instead of line by line as we do in the console. This will be the main way we leverage the power of R; by create scripts that run through a data analysis workflow we can then save these scripts as files to run at a future point, continue to develop, revise, and even share them.

Figure 15: RStudio “Editor” pane.

The Files pane has various tabs associated with it. When the ‘Files’ tab is selected we will see files and folders (aka directories) on our machine. As we begin working with R in the next section, we will begin to see how this tab will be extremely useful to see, edit, and delete our scripts, data files, and other associated project files without having to browse our system through as we would normally. There is also a set default tabs: ‘Plots’, ‘Packages’, and ‘Help’ in this pane. Plots will show and export any plots we create during our R session. The Packages tab allows us to manage packages either downloading or installing them. And the Help tab is where we access information about R in general, or particular packages, or functions. You will find that Help is really a godsend as very few R programmers can write code for a project from A to Z without refreshing their memory or exploring documentation on the usage of packages and functions.

Figure 16: RStudio “Files” pane.

The last of the four panes is the Environment pane. It includes a set of tabs as well. The main two are ‘Environment’ and ‘History’. The Environment tab allows us to see variables and objects that we create during our session. We haven’t discussed either of these concepts, but rest assured we will get there soon and you will understand how helpful this tab is to efficient R programming. History is just that; a history of the commands that have been sent to the R interpreter. These commands can come from our interactive session in the console or through running a series of commands in a script.

Figure 17: RStudio “Environment” pane.

So there you have it a brief overview of RStudio panes and tabs. Together these tools will provide us ample resources for just about everything you will ever need to do data analysis with R. In the next section we will begin to see how we can leverage these resources in a basic R session.

R sessions in RStudio

To get a basic feel for working with R and RStudio let’s run through a basic example that will highlight each of the main panes and tabs that we covered in the previous section.

To get started let’s run the same code we ran before in the R Application GUI console but now in the RStudio console. Type the following code in the Console and hit Enter on your keyboard.

1 + 1

On hitting Enter, the code is sent to the R interpreter which responds with the result; 2. For now ignore the [1] that prefixes the line where the result is displayed.

Now let’s run three separate lines of code in the Console in sequence. Take care to enter this and all subsequent code input correctly computers do not tolerate typos. Remember you’re the brains here, the computer is the brawn!

x <- 1:26
y <- letters
paste(x, "-", y)

You will notice that the first two commands did not return anything. This is because we sent the results from each of these commands to the variables x and y, respectively. A variable is a data container that is named. This container, or variable, holds the result in memory and gives us access to the result when we use the variable name later on. As you will soon see, you will inevitably create a number of variables in any given data analysis. There are two ways to see a listing of variables you have created. The first can be done in the Console by typing the function ls().

ls()
## [1] "x" "y"

The second is to browse to the Environment pane under the Environment tab. You will see that the Environment tab provides much more information that just the names of the variables in memory. It also indicates the type of each variable, its dimensions (in this case length as we are working with vectors), its memory size, and a summary of the values contained within.

Figure 18: Viewing variables in the Environment tab.

In the third command we make use of the variables x and y: pasting (with the built-in, or ‘base R’, function paste()) the results from x (a series of numbers from 1 to 26) and y (the letters of the alphabet) together with a hyphen as a separator.

If that was the result we were looking for then great. Job done. Imagine, however, that we wanted the result to return contiguous ‘number-hyphen-letter’ strings, like 1-a. Is that possible? Yes, it is. But don’t take my word for it, let’s find out using RStudio’s Help resources. Again, there are two ways to do this. The first is by inputting the code ?paste in the Console.

By appending the ? operator to a function, package, or dataset name the Help tab in the Files pane is opened to the R documentation page.

Figure 19: Viewing R documentation in the Help tab.

The second approach is to manually browse to the Help tab and search for the function paste. Either works, you might find yourself alternating between the two.

Back to our code. The R documentation shows that paste() can take an optional sub-command, or argument, that will allow us to choose how our paste variables are separated. With this knowledge in hand we can update our code. We will use the argument sep = "" to remove white space between the concatenated elements like so:

paste(x, "-", y, sep = "")
##  [1] "1-a"  "2-b"  "3-c"  "4-d"  "5-e"  "6-f"  "7-g"  "8-h"  "9-i"  "10-j"
## [11] "11-k" "12-l" "13-m" "14-n" "15-o" "16-p" "17-q" "18-r" "19-s" "20-t"
## [21] "21-u" "22-v" "23-w" "24-x" "25-y" "26-z"

With time you will become more accustomed to reading and making sense of the R documentation. For now, however, it is sufficient to have learned how and where to access this documentation.

The previous code we have run is short and simple. Working with the Console is great for this type of quick and dirty exploring, or doing some introspection of variables using ls() or the help operator ? to view the R help documentation. However, data analysis will involve many more lines of code and using the Console directly will become cumbersome. A more convenient way to write code is to use the Editor pane.

Let’s run through a more involved and practical example of creating a basic word frequency analysis. Before we get to the code below, let me introduce you to installing and managing R packages. As we have seen a couple times now there is a Console-based method and an GUI-based method. This time I will start with the GUI method as it is very convenient and tends to be the method most use. First step is to open the Packages tab in the Files pane, seen below.

Figure 20: The Packages tab.

You will see a list of the R packages that are already installed on your machine. The base installation of R comes with a default set so you will already see some packages listed. However, you may not see all of the packages that appear in Figure 20 if you have not already manually installed new packages (for example the acs package for accessing US Census data).

Let’s install a few packages we need for the upcoming code: dplyr, ggplot2, and tidytext. Installing packages with the Packages tab is easy. First, click on the ‘Install’ button within the tab.

Figure 21: The packages installation dialogue box.

Type the names dplyr, ggplot2, and tidytext into the ‘Packages’ field leaving the other default configuration fields. You will notice as you type the package names, RStudio will pattern match the name which can be helpful to make sure you type the names correctly. Once you have the names entered, click the ‘Install’ button. At this point RStudio will run the installation code for these packages. As they install there will be quite a bit of output, some of it in red , in the Console. When the installation is complete the prompt > at the Console will appear; ready to take another command.

The Console approach leverages the function install.packages(). To find out more about how to use this function, I encourage you to look at the R documentation using ?install.packages. I will leave this as an exercise for you to complete. Now back to our example code that we will enter in the Editor pane.

Copy and paste the following code into the Editor pane.

library(dplyr) # data manipulation
library(ggplot2) # package for generating a word frequency plot
library(tidytext) # package for doing a word frequency analysis

text <- c("The Fulton County Grand Jury said Friday an investigation of Atlanta's recent primary election produced no evidence that any irregularities took place.",
"The jury further said in term-end presentments that the City Executive Committee, which had over-all charge of the election, deserves the praise and thanks of the City of Atlanta for the manner in which the election was conducted.",
"The September-*october term jury had been charged by Fulton Superior Court Judge Durwood Pye to investigate reports of possible irregularities in the hard-fought primary which was won by Mayor-nominate Ivan Allen Jr..",
"Only a relative handful of such reports was received, the jury said, considering the widespread interest in the election, the number of voters and the size of this city.") # first 4 lines from the Brown Corpus

text_df <- data_frame(line = 1:4, text = text) # create a tabular dataset with the columns `line` and `text`

text.word.freq <- unnest_tokens(tbl = text_df, input = text, output = words) %>% # tokenize `text` into `words`
  count(words, sort = TRUE) %>% # count `words` and sort them
  head(10) # return only the first ten lines in the dataset

ggplot(data = text.word.freq, aes(x = reorder(words, desc(n)), y = n)) + geom_bar(stat = "identity") + labs(x = "Words", y = "Count", title = "Word frequency plot") # plot the `words` on the x-axis and the count `n` on the y-axis using a bar plot ordered by `n`

Your code should look something similar to what you see in Figure 22. Note that I have resized the Editor pane to view most of the code.

Figure 22: Code for a basic word frequency analysis in the Editor pane.

We can run the code in the Editor pane either line by line or as a complete script. Running code line by line can be useful when you are composing a script and want to test the results incrementally. To do this you move your cursor to the line you would like to run and then simply hit the keystroke command + enter (Mac) or ctrl + enter (PC). Run line 1 and see what happens!

Line 1 loads the dplyr package from our package library with the command library(dplyr). If you resize the Console pane you will see that the command was run and resulted in some details about the package printed to the Console. We also notice that the cursor has moved to the next line in the Editor pane, ready for us to run this line.

Figure 23: Running the first line of our basic word frequency analysis.

In this script I’ve also added comments to each line of code describing what each command does in our script. Any time R finds a # symbol it ignores everything to the right on the same line. We can then use plain language to annotate our code. Using commenting is a key best practice for coding in any programming language as it will make your code more legible to other users as well as the future you who might come back to this code sometime down the road to realize you have forgotten what your code does!

Returning to running our code from the Editor, we can also run multiple lines, or even the entire script from the Editor pane in a similar fashion by selecting multiple lines, or all the lines and using the previous keystroke (command + enter, or ctrl + enter). RStudio provides a button ‘Run’ that can be used to run a script line by line or the ‘Source’ button to run the entire script.

Figure 24: Running the entire script using the RStudio tool Source.

Go ahead and run the entire script now with by clicking ‘Source’. The script will be automatically sent line by line sequentially to the Console. The results of this script generate a word frequency plot for the first four lines from the well-known Brown Corpus. The Plots tab in the Files pane will automatically open revealing our plot.

Figure 25: Resulting plot from our basic word frequency analysis script.

Saving our work

At this point we may want to save the code to our hard drive to make sure we don’t lose our work, or to move on and write some other code. To save this R script navigate to the RStudio tool menu ‘File > Save’ or hit the keyboard shortcut command + s (Mac) or ctrl + s (PC). The next step is to choose where to save this file. Select a directory for this file to live. For now you can choose any directory you feel fit. As we move forward in this series and in more involved projects that you will work on, however, it’s best to do some organizational planning upfront to set up your main project directory, sub-directories, and so on so that it is clear where to save each type of file. This topic will be covered in an upcoming Recipe post dealing with project management using the RStudio ‘Projects’ feature.

For testing purposes, let’s save the file within the current working directory inside a directory we will create named getting_started/. What is the working directory? Well, it is the place that RStudio regards as “Home base” on your hard drive. To find out what this is, enter the function getwd() at the console. R will return a path to the current working directory. On my machine the path is /Users/francojc/Documents/Recipes. This notation is describes the hierarchical scheme of directories. My current working directory, then is the Recipes/ directory which is located inside the Documents/ directory which itself is located within my home directory francojc/.

Let’s go ahead and open the ‘File > Save’ tool RStudio menu and name our file basic_frequency_analysis.R. The use of _ here is to avoid white space in file and directory names. This is good practice as working with paths in programming can be complicated by white space in some environments. So it’s good practice to avoid white space. There are various styles that are employed in programming, generally, and in R programming specifically. Just like commenting code, as mentioned previously, adopting accepted style guidelines can increase your code’s legibility for you and those who may work with code you share.

Figure 26: “Save” dialogue in RStudio.

Once we have saved our file in our working directory, it will now appear in the Files tab in RStudio. From this tab you can move, rename, and delete files as well as create, rename, and delete directories as well. It’s also worth pointing out that the path to our working directory is visible in this Files tab between the working directory listing and the button toolbar. This is a nice feature to see where the files and directories live on your machine without resorting to the OS file explorer.

Figure 27: Viewing files in the Files tab.

Let’s create our getting_started/ directory inside of our working directory to house this file. Click the ‘New Folder’ button inside the Files tab and name the new directory. It will now appear in our listing. To move our file inside of this directory we can use the OS to manually move the file, but RStudio again provides tools to do this. Select the checkbox beside the file basic_frequency_analysis.R, then select ‘Move…’ from the ‘More’ dropdown menu.

Figure 28: Moving a file to a new directory in the Files tab.

After you make the move, RStudio will quickly ask you if you want to close the basic_frequency_analysis.R script as it no longer exists. It does exist, just not in the same location as before. This underscores the importance of paths in programming and programming tools like RStudio. It is therefore of utmost importance to be aware of the paths to files and directories. Luckily, RStudio provides us ample ways to monitor the paths to working files and directories!

Closing an R session

At this point let’s say it’s time to close our session and quit RStudio. You can do this by simply navigating to the RStudio tool menu ‘File > Quit session…’. You will be presented with a dialogue box to save the workspace or not.

Figure 29: Quiting an R session.

We can choose not to save the workspace and our files will be preserved (as long as they have been previously saved to the hard disk). What we lose, however, are the variables and history that RStudio has in memory at the current moment in our session. If you want to begin your next session with these variables and history loaded from the get-go, then we will want to save the workspace. Let’s choose to save the workspace to see this in action. After quitting RStudio, restart the application. Because we had chosen to save the workspace we now have our variables and history in this new R session. You can view them in the Environment pane. If you navigate to the working directory in the Files tab in the Files tab you will also see a couple new files have been added to our files and directory list: .RData and .Rhistory.

Figure 30: Workspace files .RData and .Rhistory.

When you restart another session, R will look for these files and load them into the workspace for you to pick up and continue using. If you choose to quit an R session without saving the workspace these files will not be created, or in the case they already exist from a previous workspace session, will not be overwritten and the earlier variables and history will be loaded.