• Let's generate some (boring) random data and display it:

# app.R

ui <- fluidPage(
  h1("Hello, World!"),
  tableOutput("data")
)

server <- function(input, output) {
  output$data <- renderTable(
    data.frame(letter = letters[1:10])
  )
}

shinyApp(ui=ui, server=server)

• notice how we assign to output$data in server, but use the string "data" in ui

• use selectInput():

# app.R

ui <- fluidPage(
  h1("Hello, World!"),
  sliderInput("slider", "choose a length for the dataset:", 1, 26, 10),
  tableOutput("data")
)

server <- function(input, output) {
  output$data <- renderTable(
    data.frame(letter = letters[1:10])
  )
}

shinyApp(ui=ui, server=server)

• run it!

• well of couse not, we never changed the server function:

# app.R

ui <- fluidPage(
  h1("Hello, World!"),
  sliderInput("slider", "choose a length for the dataset:", 1, 26, 10),
  tableOutput("data")
)

server <- function(input, output) {
  output$data <- renderTable(
    data.frame(letter = letters[1:input$slider])
  )
}

shinyApp(ui=ui, server=server)

• now it works!

• let's generate a more complex dataset, and sample some rows to display:

# app.R

ui <- fluidPage(
  h1("Hello, World!"),
  sliderInput("slider", "choose a length for the dataset:", 1, 26, 10),
  tableOutput("data")
)

server <- function(input, output) {
  output$data <- renderTable({
    df <- data.frame(a = runif(10000000), b = rnorm(10000000))
    rows <- sample(nrow(df), input$slider)
    df[rows, ]
  })
}

shinyApp(ui=ui, server=server)

• we needed the curly braces in renderTable because our expression is more than one line
• why is the response time so crappy?

• we were generating the dataset from scratch each time we moved the slider
• we can avoid that by generating df before calling renderTable:

# app.R

ui <- fluidPage(
  h1("Hello, World!"),
  sliderInput("slider", "choose a length for the dataset:", 1, 26, 10),
  tableOutput("data")
)

server <- function(input, output) {
  df <- data.frame(a = runif(10000000), b = rnorm(10000000))
  output$data <- renderTable({
    rows <- sample(nrow(df), input$slider)
    df[rows, ]
  })
}

shinyApp(ui=ui, server=server)

• so much faster! We only generated df once, when we first connected to the app
• only the renderTable call runs when input$slider changes; that's reactivity!

• put the front end in a file ui.R, and the backend in server.R:

# ui.R

fluidPage(
  h1("Hello, World!"),
  sliderInput("slider", "choose a length for the dataset:", 1, 26, 10),
  tableOutput("data")
)

# server.R

function(input, output) {
  df <- data.frame(a = runif(10000000), b = rnorm(10000000))
  output$data <- renderTable({
    rows <- sample(nrow(df), input$slider)
    df[rows, ]
  })
}

• remove the old app.R (file.remove("app.R")) and run it the same way as before
• we don't need to assign the fluidPage/function to variables anymore

• try refreshing the page; see that delay?
• currently, our df is created when the function in server.R runs, which is when a client (browser) connects
• we can make the variable global by breaking it out of the function inside server.R:

# server.R

df <- data.frame(a = runif(10000000), b = rnorm(10000000))

function(input, output) {
  output$data <- renderTable({
    rows <- sample(nrow(df), input$slider)
    df[rows, ]
  })
}

• refresh; faster, right?
• now df is generated once when we call runApp, instead of each time someone connects

• at Barracuda, we like to remove as much code from server.R and global.R as possible
• this makes the logic easier to read, particularly when your reactive model becomes complex
• put all the workhorse code in functions inside a file like functions.R:

# functions.R

makeData <- function() {
  data.frame(a = runif(10000000), b = rnorm(10000000))
}

makeTable <- function(df, n) {
  rows <- sample(nrow(df), n)
  df[rows, ]
}

• you can call this file whatever you like, as we have to source it in ourselves

• source functions.R in global.R, and replace the old code to make df:

# global.R

source("functions.R")
df <- makeDate()

• and to generate the table in server.R:

function(input, output) {
  output$data <- renderTable(makeTable(df, input$slider))
}

• can you put the renderTable call in makeTable? try it out