Global

The global.R file is where you put all of the static objects that your application needs in order to run. For example, the code needed to read in the data for the app should go here. Also, all of the packages that your app uses can be loaded in the global file. If you aren’t sure what to put here, think about what parts of your app are not reactive and can be calculated at the time the app opens.

library(shiny)
library(shinythemes)
library(shinyalert)

data <- faithful

User Interface

In the ui.R file you set up how the app looks to the user. You can also designate place for the user to interact with. The way Shiny organizes the application layout is through panels. Inside the Panels, you can place widgets for input from the user and the reactive output that follows. These panels and layout functions are nested within each other to create the layout of your app. As with most things in R, it is completely customizable. Some common layout functions that are used are as follows:

• fluidPage(): allows the web page layout to adjust as needed depending on the size of the website window
• sidebarLayout(): formats the overall layout that includes two panels, sidebar and main. Usually, the sidebar is for input widgets and the main panel holds the output.
• titlePanel(): where to put the title of the application
• wellPanel(): creates a panel that has background shading

Each input widget gets it’s own name to keep track of the information there. The functions for the input widgets have the form *Input(inputID= "name", label = "Instructions for using the widget."), where the * is the type of widget you want to use. The reactive panels follow a similar format except using the word “Output” in the function names. The output panels correspond to a render function in the server for the app. An example of the user interface file is below.

shinyUI(
  fluidPage(
    titlePanel("Hello World!"),
    sidebarLayout(
      sidebarPanel(
        # Input: Slider for the number of bins 
        sliderInput(inputId = "bins",
                    label = "Number of bins:",
                    min = 5,
                    max = 50,
                    value = 30)
        
      ),
      
      mainPanel(
        # Output: Histogram 
        plotOutput(outputId = "distPlot")
      )
    )
  )
)

There are so many options for widgets and output panels. A full list can be found in this cheat sheet.

Server

The last piece of the application is server.R. Here you take the input from the user and create output. It’s everything that needs to happen behind the scenes in your app. It’s where all the reactivity comes in to your app. The user gives the app a value through the UI and the server takes that information and runs it through whatever R code you write to create the output.

The server itself is actually a function of this input and output. Consider those to be vectors holding all of that information. Because they are vectors, when they are referenced in the code you need to use vector notation: input$name. The result of the function is the redefined output vector.

The code for processing the input information is contained within a render*() function, where the * corresponds to the type of output that will be produced. It should match the output function used to display the final product of the code in the user interface. The sort of code that you can include in the render functions is only limited by what you can do in R. Just about anything is possible!

shinyServer(function(input, output) {
  # Histogram of the Old Faithful Geyser Data 
  # with requested number of bin automatically
  # re-executed when input$bins changes
  output$distPlot <- renderPlot({
    
    x    <- faithful$waiting
    bins <- seq(min(x), max(x), length.out = input$bins + 1)
    
    hist(x, breaks = bins, col = "#75AADB", border = "blue",
         xlab = "Waiting time to next eruption (in mins)",
         main = "Histogram of waiting times")
  })
})