Introduction to R

Why R?

Simply, it's what I use 99% of the time. But also:

R is free. Not all students get licenses through their school for statistical software packages. Coding in R helps increase the reproducibility of research. In a matter of minutes, anyone can run a standard R file on their computer for free. This helps non-academics reproduce your research as well. There's also no paying for updates. If your version of R is outdated, just download the new version. For free.

R is open source. There are over 15,000 packages for R. At some point, someone probably had the same question as you and designed a package for it. Simply plug and go for your analysis. Disclaimer: Some view the open source as a negative aspect of R citing that the packages may not be reliable. This is typically not an issue for commonly used packages. Just remember to be careful.

After typing 1+1, hit enter to get an answer from your computer:

The computer should calculate the correct answer, 2. At this point, you're practically a professional in R. You've learned how to talk to your computer, and that's half the battle. The rest is learning how to ask your computer more difficult questions (i.e. learning more of the R language).

Notice that the computer also returned [1]. This is not technically part of the answer, it is actually the index for the value 2. Why? Because the computer returned a vector where 2 is the first and only element. This leads us to our next section: Data Types and R-objects.

Packages

What R packages? Typically, a package includes extra functions to speed up your code, or ask your computer different questions. As mentioned earlier, there are over 15,000 R packages. Most of these are stored on the Comprehensive R Archive Network (CRAN). Packages stored on CRAN are easy to install. In the console, type install.packages("data.table").

Something similar should display in your console after hitting enter. I already had the package data.table installed on my computer. In this case, install.packages() simply updates the data.table package.

Remeber the Plot/Help panel? If we take a look under the tab "Packages", we should see that the data.table package is installed.

Notice that the package datasets has a blue checkmark next to it while data.table does not. This is because we have not yet loaded in the data.table package to R. We have simply installed the package to the computer.

What happens if we try to use a function in the data.table package right now? Type dt_Wages = data.table(Wages = vec_y, Gender = vec_x) into the console.

This should have generated an error. The first line Error in data.table(Wages = vec_y, Gender = vec_x) : tells you where the error is in your code. The second line could not find function "data.table" tells you what the error is.

Another way to think of packages is as vocabulary or slang. When we installed R at the beginning of the chapter, we taught our computer the language. When we install packages, we teach the computer additional vocabulary/slang in the R language. Every time you open RStudio, it assumes you're using "regular" language (base R). If you wish to use a package (slang), you need to tell R to talk that way. We do this by typing library(data.table). Note: When installing a package, the package goes in quotes install.packages("data.table"). When adding a package to the library, there are no quotes library(data.table).

After typing library(data.table), there should be a blue checkmark next to the data.table package.

If you forget what packages/slang you are currently using, you can always look at this panel to see which packages have checkmarks. Remember, every time you close and re-open R, you need to say which packages you want to use.

Now that we told the computer that we're using data.table slang, let's try to make a data.table of wages again, dt_Wages = data.table(Wages = vec_y, Gender = vec_x). There should not be an error in the console this time. Now that the computer understood what we were saying, it should have added dt_Wages to the environment panel.

Notice that dt_Wages is located under the subheading Data. All of the previous vectors that we made are under the subheading Values. Why? Recall that vectors and lists are "one-dimensional" while matrices and data.tables are "2-dimensional." A general rule of thumb is that R-objects with the capability to have more than one dimension are allocated to the Data subheading. So even if we made dt_Wages with just one column, it would still go under Data.

From here, there are several things we can do to view the data. Notice the blue arrow to the left of dt_Wages. If we click on the arrow, we should see

Now, we see two columns in dt_Wages. These are Wages and Gender. We also see the type of each column. Wages is numeric while Gender is a character column. Notice that this cuts off part of the Gender column. If we want to View() the entire data.table, then we need to click anywhere on the dt_Wages line except for on the blue arrow.

This should have created a new panel. I'll refer to this as the Source/Data Panel. This panel now displays a visual representation of the entire dataset. The "first" column is just the row index.

Now, close RStudio. A pop-up asking you to "Save workspace image" should appear. Click "Don't Save".

I almost always recommend clicking don't save. Why? Clicking save would have saved all of the Data and Values in the Environment Panel. If you have a lot of data loaded in, this will slow down RStudio the next time you try to open it.

Now, reopen RStudio. Everything in the Environment Panel should be gone. The Console Panel should not have any code in it. "But what if we wanted to work with cross-section data of wages and gender again? You just told me not to save anything."

The next section shows the steps to create, write, and save a .R file (think .do file in Stata).

Some quick notes while we're here. You can skip to the next shaded section if you like.

Always comment your code! I can't stress this enough. Projects last a long time. Our memories don't. There's nothing worse than wasting a day trying to figure out what your code says after you haven't looked at it for six months. This is even more important if you're working on a joint-project with multiple people coding. It's also important for people trying to replicate your project after it gets published in the AER.

While we're on organization, you' probably noticed how I like to name R-objects by now. I first write an abbreviation of the type of the object (dt for data.table, vec for vector, df for data.frame, mat for matrix). Why? Most of the time, you'll be working in the Source panel with a .R file. If you don't run the code, it won't generate the Data and Values in the Environment panel; so you might not know what type of R-object you're working with. This can create issues as some functions only work for data.frames, but not data.tables and vice versa.

After the R-object abbreviation, I write an underscore followed by what the main variable the object is recording. For vectors, this is simple. For objects with more than one-dimension, I like to write the dependent variable. Thus, dt_Wages. This is just personal preference. Do what works for you. Just try your best to stay consistent within a project (something I'm still working on).

Last part on organization. I like to start my .R files with two lines. The first line says what project is this code for. The second line says what the code does.

You should notice two things slightly different from before. I added a line of code to clear the contents of the working environment, rm(list = ls()). Let's say that you just ran a separate .R file that saved some Data and Values. These could mess up the analysis of our new file which is why we clear the contents.

You should also notice on line 13 that, rather than writing out Male and Female three times each, I used the function rep(). This function replicates a value x. In this case, I said rep(x, each = 3), but the default is rep(x, times = 3) or rep(x, 3). What's the difference? The default rep function will replicate the entire vector x three times. This would result in ("Male", "Female", "Male", ...), but we wanted ("Male", "Male", "Male, "Female", ...). Using each = 3 says replicate each element in x three times sequentially. Note: rep() is a commonly used function for me. Having to distinguish between whether I want to use each or the default times is also a common occurrence which is why I mentioned this here.

Using data.tables

This section explains the basics of data.tables. For any empirical work, data.tables will be our workhorse. They're basically a data.frame on steroids. Honestly, one of the coolest things I've ever seen. I'm only describing the basics of data.tables in this section. They can do a lot more which gets slowly introduced throughout the book. If you ever have issues or want to see some of the other cool things, then check the recommended readings. Recommended Reading: Introduction to data.tables and the FAQ. Section 1 of the FAQ is specifically for beginners. Note: After R inevitably wins the R vs Stata argument, most people move on to the data.table vs dplyr argument. dplyr was created as part of the "tidyverse" by Hadley Wickham. This book will focus only on data.tables. In your free time, it might be wise to acquaint yourself with the dplyr language as it varies quite drastically from base R and data.table.

Go ahead and click the "Source" button if you haven't yet. This should have ran the entire file and created the data.table dt_Wages as before.

We currently have each individual's hourly earnings. Let's say that we want to add a new column of their yearly earnings. But we already made the data.table, how do we add the column? To add new columns in a data.table, we use := to assign the values. We can approximate yearly earnings by 2000*Wages. To update the dt_Wages, we write dt_Wages[, EarningsYearly := 2000*Wages]. Run this line by itself as was described above. Then click on dt_Wages in the Environment panel to open the data in the Source/Data panel.

So what happened step-by-step? First, we wrote dt_Wages. This tells the computer which object we are talking about. Then we wrote [, ]. Why is the comma needed? A data.table is set-up as dt[i, j, by]. For now, forget about the by section. This is then just standard matrix notation, mat[i, j], where i represents the rows and j represents the columns. Since we left the i section blank, this means "for all rows". After the comma, we wrote EarningsYearly :=. This says to create/update a column named "EarningsYearly". Lastly, we wrote 2000*Wages. This says what to assign to the elements of the new column.

But what if we only wanted to select some rows? Assume that the approximation of yearly earnings of 2,000 times hourly wages was calibrated to the average male hours worked per year. Next, assume that females work 5% less hours per year. The values for female are then overestimated. To correct this, we can update the EarningsYearly column just for females by writing dt_Wages[Gender == 'Female', EarningsYearly := 0.95*EarningsYearly]. (You may need to click on the "Untitled1" tab to return to writing your .R file.)

After writing, run just this new line. If you click on the "dt_Wages" tab in the Source/Data panel, you may see that nothing updated. Why? Because you're still viewing the old data. To view the new data, again, click dt_Wages in the Environenment panel. Now it should have updated the values for females.

At this point, you've learned how to create/update columns. You've also learned how to assign values to specific rows in a column. So you should be starting to get used to what i and j do. But what about the by part in dt[i, j, by]? Let's assume that we also see the houshold each individual belongs to, vec_hh = c(1, 1, 2, 2, 3, 3) or if you remember from earlier vec_hh = rep(c(1, 2, 3), each = 2). Create a new column called id_household with these values in dt_Wages.

Now, let's calculate yearly household income. To do this we write, dt_Wages[, EarningsHH := sum(EarningsYearly), by = c('id_household')]. If you view the data, you should now see:

You can manually check that this calculated each household's income correctly. Now, you should start to have an understanding of dt[i, j, by]. As one more example, let's say we're writing a report on the gender wage gap. So we want to calculate the average earnings for males and females separately. Also assume we want to analyze both the unconditional gender wage gap for yearly earnings and the conditional (on hours worked) gap. Similar to above, we could make two new columns in dt_Wages by writing dt_Wages[, `:=`(EarningsGender = mean(EarningsYearly), WagesGender = mean(Wages)), by = Gender]. Note: An accent ` goes before and after := when assigning multiple columns in a data.table. This is not an apostrophe, '.

Note 1: I recommend using the spacing in the figure above when assigning multiple columns. Thus, there is one new/updated column per line. After all new columns are written out, I then return one more time for the by statement. Note 2: Notice the difference between the by statements on lines 29 and 34. Either is correct when conditioning the by statement on only one variable. Let's say we had a panel and we wanted to find each household's income for each year. We would have to write by = c('id_household', 'Year').

Although the method on lines 32-34 works fine, assume that we don't care about individual or household income. Now, dt_Wages is full of a bunch of extra information that we don't need. (This is common in other settings such as aggregating data from the county to the state-level and we just want to work with the state-level data.) In this case, we don't want to create new columns. We want to create a new data.table. Luckily, the code is almost identical. There are two differences.

First, we need to change `:=` to a period .. Instead of creating new columns, this tells the data.table to perform the operations and "collapse" on the by statement. Second, we need to name a new data.table. Let's call it dt_GenderGap. Altogether, we now have dt_GenderGap = dt_Wages[, .(Earnings = mean(EarningsYearly), Wages = mean(Wages)), by = Gender]. Running this line will create a new item in the Data section of the Environment panel. If you click the dt_GenderGap line, your RStudio interface should look like this:

As the last step, we'll now calculate female earnings as a percentage of male earnings to summarize the wage gap. To do this for earnings, we write dt_GenderGap[, 100*Earnings/Earnings[Gender == 'Male']]. Notice that selecting specific rows works in the i position as we showed earlier, as well as the j position as in this example. Here, we selected a specific value of Earnings to divide the entire Earnings column by. Also, notice that we did not use the assignment operator :=. Thus, R does not update dt_GenderGap. It simply prints the output of the question to the Console panel.

Write and run this line for the wages as well to calculate the conditional gap on hours worked. In the Console panel, you should see:

In this example, females make 90.2 cents for every dollar a male makes throughout the year. After accounting for differences in hours worked, females make 94.9 cents for every dollar a male makes. Now we have the information to write our report on the gender wage gap. What if we wanted to save our code to work on it later?