Why R?

R is a powerful programming language and free software environment used for statistical computing and data analysis and reporting. Since the R language was developed by and for statisticians it becomes a natural choice for data analysis and data science teams.

Additionally, R comes with a very powerful integrated development environment (IDE) called RStudio that can allow a data science team to work, collaborate and create reports, all in one environment.

Another great advantage of R over other programming languages is the wide range of tools they offer in tidying the data. In an R framework, tidying data refers to the process in which the data is transformed in such a way that the final dataset has each variable on a separate column and each row is a new observation. This approach makes it easier to extract information out of data and it makes it easier to reuse code or an analysis on a new dataset.

“Like families, tidy datasets are all alike but every messy dataset is messy in its own way. Tidy datasets provide a standardized way to link the structure of a dataset (its physical layout) with its semantics (its meaning)”

The last advantage I would like to mention is the transparency and re usability of using using code over a point and click approach (e.g. using Microsoft Excel or a Business Intelligence software). When you have a report or an analysis written using code it can be run by anyone, they just need to run the code in the required order. If you have multiple datasets that require the same approach, transformation, summary, etc, you can do that with just one run of the code, as opposed to a point and click approach where most of the times you need to process the files one after the other. And the best thing about writing code for data analysis, it can be easily shared between team members and reused in multiple projects.

Visuals in R

Graphics and visuals are a big part of data analysis and reporting. R offers a wide range of tools that can cover all data visualization needs any data analysis or data science might need. The most flexible and most widely used of these tools is the ggplot2 package and that is the one we will use to demonstrate the power and flexibility of visuals in R.

The power of ggplot2 comes from the way in which it creates the graphs. ggplot2 creates graphics in layers, at first it creates a canvas on which to display the visuals, then it adds different layers of visuals, one over the other.

The canvas is simple enough, it just needs some parameters to know what values to display. This will be the X and Y axes and the values we need to declare are the columns we want to become the X and Y columns respectively.

Once we have done that, we need to specify what geometrical shapes (geom) we want to represent the data. These are the visuals most people see and the ones that show the relationship between the data. The geom can be a point, a column, a bar, whatever we need to better display the data.

Before we proceed I would like to explain why this approach is so powerful. By the simple fact that we basically add separate elements on top of another on a canvas, we can control each element as we please. If we just add a geometrical shape, the software will add it according to the X and Y axes on the canvas. However, if we want to display a different dataset, or an element that is on a different scale, we can do that.

I know it sounds a bit complicated, but it is not and we will explore it in more detail below. Let’s start with a basic plot. We can check the code and discuss it afterwards.

library(ggplot2)

ggplot(data = mtcars, mapping = aes(x = hp, y = mpg)) +
         geom_point()

Basically in the code above we have two main parts divided by a +. In the first part we have the function that creates the graph ggplot, the data we want to use mtcars (a dataset provided by R) and the columns we want to use for the X and Y axes. For the second part we have the geom we want to use, in this case a point.

I know this can be confusing, so let’s break the code apart and see if we can understand it better. I will explain it from a technical point of view at first, then we can write the code once more and see if we understand it better.

When we use the graphic function (ggplot()), we are required to provide some details (we can find more about it by using the code ?ggplot or pressing F1 while your cursor is on the function). The details we needed to provide at first where:

• the dataset
• the X Axis
• the Y Axis

Now let’s discuss these particular parameters. In our case the dataset is quite simple, it the mtcars dataset and it looks like this:

Now that we see the data I think we can clarify better what we did above so let’s try it. The function takes the dataset and using the mapping = function it can translate the values from columns in the dataset to the axes on the canvas. So, let’s see the code one more time and break it down, than we can add more elements to see exactly how this works. I will comment each element by using a # before the comment.

ggplot(
  # The dataset we want to use
  data = mtcars,
  
  # The next step is to map the columns from the data to the function
  # aes() is a function required for the mapping function
       mapping = aes(
         
          # We need to specify the two axes
                     x = hp,
                     y = mpg)) +
  
  # A geometrical form we want to use for displaying the data
         geom_point()

I would like to explain a bit more the importance of mapping. This is just a way to assign values from the dataset to different dimensions of the canvas. The elements are not just the X and Y axes, they can be anything else that offers additional information, colour, titles, shapes, etc.

In the example below I will add colours to the graph according to the number of cylinders (cyl). We will also add the model to make it easier to check the values and compare them in the table should we want to do so.

ggplot(data = mtcars,
       mapping = aes(
         x = hp,
         y = mpg,
         colour = cyl,
         label = Model
       )) +
  geom_point() +
  geom_text(vjust = -0.5)

If we use the same line (colour = cyl) outside the mapping function we will get an error because R does not know where to find the cyl object. However, we can use the colour parameter outside mapping, if we want to use it as a global parameter for an aesthetic purpose. In geom_point we can pass the colour = argument with either a colour (e.g. red, blue, green) or a HEX code (e.g. #2815E3)

ggplot(data = mtcars,
       mapping = aes(
         x = hp,
         y = mpg
       )) +
  geom_point(colour =  "#2815E3")

We can find more about the different geometrical forms that we can use here.

Increasing complexity in visuals

library(dplyr)                  # library we need to transform the data
                                
# Dataset + pipe operator
mtcars %>%
  
  # filter the data so only the rows that have the value 6 on the cyl column remain
  filter(cyl == 6) %>%
  
  # keep just the two mentioned columns
  select(Model, cyl) %>%
  
# Styling to make the table easier to see
  kable(format = "html") %>%
  kable_styling(bootstrap_options = c("striped", "hover", "condensed", "responsive"), fixed_thead = T)

kable_styling(
  kable(
    select(
      filter(mtcars, cyl ==6), Model, cyl
      ), 
    format = "html"), 
  bootstrap_options = c("striped", "hover", "condensed", "responsive"), fixed_thead = T)