Switching from Stata to R

Packages

Packages are the reason that R is such a powerful tool. Packages can be thought of as a collection of functions, typically centered around a particular theme or method. Base R is refers to the functions included by default when you install R on your machine. The main thing to know with R packages is that if you can imagine a function, someone’s probably already written a package for it.

I personally find that base R code can be quite arcane to read, which is why I’m such a tidyverse fan. The tidyverse is a collection of packages that is incredibly popular and for good reason; the design of the packages share consistent philosophy around how code should be written (see their website if you want to learn more).

To install R packages just run install.packages("<package name>"). To use the package, run library(<package name>) to load in all the functions from that package into your current R session.

You can also use specific functions from packages by loading the functions in specifically (using include.only), or by explicitly calling the function without loading the package (using ::), demonstrated in the example below.

library(haven, include.only = "read_dta")
auto <- read_dta("/Applications/Stata/auto.dta")

auto <- haven::read_dta("/Applications/Stata/auto.dta")

Multiple datasets

Stata can sort of do this but nothing like how R does. Instead of using frame to create and manage multiple in-memory datasets and frame change to switch between datasets, you can just load multiple datasets into R, assign them names, and simply call these names when going about your work, no explicit switching required. I won’t go into detail here as you’ll very quickly figure this out as you start to use R, but I think it’s one of the greatest advantages of R over Stata.

Pipes

Using the auto dataset as an example, say we wanted to create a dataset of only domestic cars and analyse their weight to length ratio by brand. In Stata, each line of your code would be executed sequentially and independently with the results window returning something after each step:

sysuse auto
drop if foreign == 1
gen wgt_len_ratio = weight/length
gen brand = substr(make, 1, ustrpos(make, " ")-1)
sort brand
by brand: summarize wgt_len_ratio

You can write R code in this fashion too but there’s something nice about using pipes. You can think of pipes as literal pipes, you put something in at one end of the pipe and something comes out the other end. In our case, data goes in one end, your code is what happens inside of the pipe, and the result of your code is what comes out the other end. In R there’s two different pipes, the base pipe |> and the magrittr pipe %>%. You probably don’t need to worry about the difference for now, but for those interested see this post on the tidyverse website.

The same operation as above in R could be done as:

auto <- haven::read_dta("/Applications/Stata/auto.dta")

auto |> 
  filter(foreign == 0) |> 
  mutate(
    wgt_len_ratio = weight/length,
    brand = str_extract(make, "\\w+")
    ) |> 
  group_by(brand) |> 
  summarise(
    n = n(),
    mean = mean(wgt_len_ratio),
    sd = sd(wgt_len_ratio),
    min = min(wgt_len_ratio),
    max = max(wgt_len_ratio)
  )

It’s a little longer in length than the Stata example, however I find pipes and tidyverse in particular make the code more readable and easier to follow and navigate (the indentations also help). The auto dataset goes in to the start of the pipe, we perform some operations to it, and the output of the pipe is the summary we wanted.

Assigning output

One of the main things to adjust to in R is the need to assign your output. In Stata, if you were to create a new variable, you would just write gen new_var = old_var*2 and it would automatically create new_var in the current dataset. Similarly, if you run a regression model, Stata stores a bunch of information in the background that you can access, such as via the lincom and margins functions.

In R, the default is to display the output of your code in the console (similar to Stata’s results window). So if you were to run auto |> mutate(new_var = 1) it would just print the result in the console. Instead, you need to assign the output using the assignment operator <- to an object, either an existing or a new one. For example:

• auto <- auto |> mutate(new_var = 1) writes over the object named auto, which is our dataset
• auto_new <- auto |> mutate(new_var = 1) creates a new object called auto_new and leaves the original auto object unchanged

In the example where we calculated summary statistics by car brand, if you were to run the R code it would simply output the summary statistics in the console. If you wanted to do something with the summary statistics later, you would assign the output.

One aspect of this feature is that it completely circumvents the need for Stata’s preserve and restore. Just assign the output of your code to a new object where you would instead have used preserve and restore. This makes it handy for analyses of data at different stages of cleaning or analysis.

Further resources

The resources I would recommend for learning more R are:

• R for Data Science
• Advanced R
• ggplot2: Elegant Graphics for Data Analysis
• Fundamentals of Data Visualization

Note that Fundamentals of Data Visualization doesn’t include the R code by default. Instead, Claus provides a link on the welcome page to the book’s GitHub repo, which you can search through to find the code to replicate the graphs in the book.

Modifying variables

A lot of data cleaning work involves modifying or creating variables in some way. In the tidyverse, variables are typically created or modified using the mutate() function.

Other basics

These functions are more about performing other operations to datasets than changing or modifying variables.

Regression

The correspondences here represent the models that you need to run to generate (usually) the same results, not the code that will produce the same output. If you simply run the R code it will output something minimal, instead you will want to assign the model to an object. For the linear regression example, this would be model <- lm(price ~ mpg, data = auto) followed by using the summary function on that object summary(model).

I say ‘usually’ the same results because for some methods there seems to be some minor difference under the hood that means estimates differ slightly. For example, in the negative binomial example the standard errors for mpg are different at the 4th decimal. Always check your outputs :)

Finally, I only include some basic regression models here. In epidemiology we often need to deal with observations that aren’t independent, such as in longitudinal studies. Methods such as generalised estimating equations (GEEs) and mixed effects models are supported in R. For GEEs, see the gee package (link). For mixed effects models, the lme4 (link) is popular.

Histograms

auto |>
  ggplot(aes(x = weight)) +
  geom_histogram() +
  theme_bw()

Density plots

auto |>
  ggplot(aes(x = weight)) +
  geom_density() +
  theme_bw()

Bar charts

auto |>
  ggplot(aes(x = headroom, y = rep78)) +
  geom_col() +
  theme_bw()

Line charts

auto |>
  ggplot(aes(x = weight, y = length)) +
  geom_line() +
  theme_bw()

Scatter plots

auto |>
  ggplot(aes(x = weight, y = length)) +
  geom_point() +
  theme_bw()

Box plots

auto |>
  ggplot(aes(x = foreign, y = price, group = foreign)) +
  geom_boxplot() +
  theme_bw()

Violin plots

auto |>
  ggplot(aes(x = foreign, y = price, group = foreign)) +
  geom_violin() +
  theme_bw()