Why interactive and why Shiny?

Open Science

• Interactive web apps are a great way to make our research open, transparent, and engaging
• Move beyond static papers

Shiny

• Performative apps without HTML, javascript, CSS…
• Range of users - academics to tech companies
• Need to be hosted on a web server

Server options

• shinyapps.io: free or subscription options
• See here for more info on Rshiny servers
• There are other ‘non-R’ server options out there too

App fundamentals

Interactivity requires Reactivity

What is reactive programming?

• Outputs react to inputs

  • Means computations are only done when necessary (moving beyond functions to reactions)
  • Reactive contexts are lazy and cached

• It’s different from how we normally code our scripts:

  • Commands vs. recipes
  • Imperative vs. declarative
  • Assertive vs. passive-aggressive

Shiny

{shiny} provides a framework for reactive programming:

• User-interface (ui): how it looks. Takes inputs and displays outputs
• Server: has the recipe to turn inputs into outputs

hint: if you have {shiny} installed, just type shinyapp in your R script to insert boilerplate shiny app code and get started quickly

library(shiny)
ui <- fluidPage(
  
)
server <- function(input, output, session) {
  
}
shinyApp(ui, server)

A simple histogram

hist(rnorm(25))

A reactive histogram

library(shiny)
ui <- fluidPage(
  numericInput(inputId = "n", "Sample size", value = 25), 
  plotOutput(outputId = "hist")
)
server <- function(input, output, session) {
  output$hist <- renderPlot({
    hist(rnorm(input$n))
    })
}
shinyApp(ui, server)

You’ll need to hit the ‘Run app’ button in the top right corner of your script.

Note There’s an additional reactive tool, reactive expressions. Reactive expressions can be used to eliminate redundant code in your app, thereby improving efficiency. Find more information here.

But what about maps?

My go-to for mapping in R these days is {tmap}

One of the reasons is that I can make either interactive or static, publication-quality maps with ease. Just set the ‘mode’.

library(tmap)
data('World')
tmap_mode('view')

## tmap mode set to interactive viewing

qtm(World, 'name') # qtm stands for 'quick thematic mapper'

Share with shiny

If we’re in a hurry, we can put our interactive {tmap} in a {shiny} app to share

library(shiny)
library(tmap)
data('World')
ui <- fluidPage(
  tmapOutput('map')
)
server <- function(input, output, session) {
  output$map <- renderTmap({
    qtm(World, 'name')})
}
shinyApp(ui, server)

Don’t forget to hit the ‘Run app’ button in the top right corner of your script

Add some reactivity

Let’s add a widget to allow users to choose their country from a list

library(shiny)
library(tmap)
library(dplyr)
data('World')
ui <- fluidPage(
  tmapOutput('map'),
  selectInput('var', 'Select country',
              choices = c('Global', as.character(World$name)),
              selected = 'Global')
)
server <- function(input, output, session) {
  output$map <- renderTmap({
    if(input$var == 'Global'){
      qtm(World, 'name')
    }else{
      qtm(filter(World, name == input$var))
    }
  })
}
shinyApp(ui, server)

Don’t forget to hit the ‘Run app’ button in the top right corner of your script

Customising and scaling your interactive map

If you want to customise your map with more features, the leaflet R package offers some nice functionality (there are others too)

{tmap} and {leaflet} both use ‘scalable vector graphics’ (SVG) to visualise maps on the web

• This is fine for simple apps, but if you need to render large datasets or do complex computations they will be really slow

Scaling-up your map app might require graphics to be rendered in ‘WebGL’ instead of SVG

• There are several R packages to try including mapdeck and rdeck
• These usually require API tokens to access basemaps from mapbox

Should I go SVG or WebGL?

• Generally I’ve found there is a feature vs. speed trade-off
• Recommend start with SVG and if too slow then move to WebGL

Tips and tricks

• Lots of complex polygons? Use rmapshaper to simplify, this can really speed up a slow map app
• App still slow? Use profvis to profile your script and find the bottleneck
• Have you reached the ‘cliff of complexity’? Check out Engineering production grade shiny apps

Leaflet example

Head over to Christina’s public github repo and clone to your local computer. This will give you access to all of the scripts and data you need to:
1. Build an interactive {leaflet} map: follow the R script ‘leaflet-map.R’
2. Turn the interactive {leaflet} map into a share-able and dynamic {shiny} web app: follow the R script ‘leaflet-app.R’

About the author

Christina is a quantitative ecologist at Griffith University interested in conserving blue forest ecosystems and informing climate-smart coastal restoration.