Knit with parameters

# specify parameter in yaml header
title: "example"
output: html_document
date: "2024-05-09"
params:
  actor:
    label: "Actor"
    value: "Keanu Reeves"
    input: select
    choices: ["Keanu Reeves", "Alec Baldwin","Arnold Schwarzenegger"]
    multiple: yes

# assign parameter to object
actor<-params$actor

# use parameter in code
tmptbl<-dfmv %>% 
  filter(Actor %in% actor)

Self-publish

With quarto we can easily create website and books. Quarto website and Quarto book projects create default files.

Preview

quarto preview

Render

quarto render

Publish

quarto publish quarto-pub

We are not developing

Applications in the common sense - Spotify, Instagram or the like.

But we are developing

Applications serving a supportive role for your research, your skills or expertise.

Applications wrapped around parameterized reports and/or repetitive code.

Examples

The set up

The work environment

The virtual space where we create the shiny app. It contains packages, scripts, and data.

Packages

We need the package shiny. If you haven’t done so yet, please install now.

install.packages("shiny")
library(shiny)

Source scripts

We might have code or custom functions saved in a separate r script file. This can be sourced into the app.

It helps with keep the workenvironment structured!

source("")

Load R data

We might have saved data after having manipulated it (cleaned, filtered etc) as an R data object. This can be loaded into the app.

It saves computing time but it is static meaning that you are limited to the saved data object itself. No access to original or raw data.

load("")

Sourcing code

In previous sessions, we wrote a basic function to add a constant to all numeric columns to a data frame.

We can copy this function into an .R script so that we have access to it in writing our first shiny app.

func1<-function(df,n){
  
  tmp <- Filter(is.numeric, df) # we first filter the dataframe for numeric columns
  
  tmp + n # we then add the constant to all the numeric columns
}

Loading R data objects

Before we start working on the shiny app let us save the data (Stanciu et al., 2017) into an .Rdata format.

This makes it somewhat easier to import the dataframe in the shiny app code, as it is already in an r format.

# imports data in SPSS .sav format
# make sure to actualize the path to the data file so that it matches your directory
dfex<-haven::read_sav("data/sample.sav")

# saves R object dfex into an .Rdata format 
# which we load into the shiny app shortly
save(dfex,file="data/sample.Rdata")

Once created, we can load the .Rdata object as follows:

load("data/sample.Rdata") # be sure to specify the path to your working directory

Shiny apps structure

  ### calls r script files
# source("functions.R")

### loads data
load("data/sample.Rdata")

### imports libraries
library(shiny)

r <- getOption("repos")
r["CRAN"] <-"https://cloud.r-project.org/"
options(repos=r)

# install.packages("pacman")

# pacman::p_load(tidyverse,readxl,haven,sjlabelled,kable,kableExtra)

#### shiny app starts here ###

# Define UI for application that draws a histogram
ui <- fluidPage(

    # Application title
    titlePanel("Illustrative example"),

    # Sidebar with a slider input for number of bins 
    sidebarLayout(position = "left",
                  
        sidebarPanel(
          
          # actor input
          selectInput("actor",
                      label="Choose an actor:",
                      c("Keanu Reeves",
                        "Alec Baldwin",
                        "Arnold Schwarzenegger",
                        "Timothee Chalamet",
                        "Anamaria Marinca"),
                      multiple = TRUE),
          
          # stereotype input  
          selectInput("stereotype",
                        label="Stereotype dimension:",
                        c("Warmth women" = "wom_warm",
                                  "Competence women" = "wom_comp",
                                  "Warmth men" = "men_warm",
                                  "Competence men" = "men_comp"))
            
        ),

        # Show a plot of the generated distribution
        mainPanel(
          
          h3("Output displayed here",),
          # start tabset Panel
          tabsetPanel(
            
            # tab 1
            tabPanel("Actors",
                     
                     tags$p(HTML(paste("A table is generated based on the actors chosen on the side panel..", sep = "")) ),        
                     
                     DT::dataTableOutput("act") ),
            
            # tab 2
            tabPanel("Stereotypes",
                     
                     tags$p(HTML(paste("A plote is generated based on the variable chosen on the side panel..", sep = "")) ),
                     
                     plotOutput("st") )
            
          ) # close tabset Panel
        )
    )
)

# Define server logic required to draw a histogram
server <- function(input, output) {

  ####### -- imports and prepares data from here 
  
  # reactive object
  # data from Stanciu et al. 2017
  
  tempdf <- reactive({
    
    choice=input$stereotype
    
    dfex %>% 
      sjlabelled::remove_all_labels() %>% 
      pivot_longer(contains("warm") | contains("comp")) %>% 
      filter(name %in% choice)
  
  })
  
  # reactive object
  # meta data movies
  movietmp<- reactive({
    dfmv<-readxl::read_excel("mat/movies.xlsx",1) %>% 
      filter(Actor %in% input$actor)
    
  })
  
    #### -- generates output objects from here
  
  # generate ggplot
  plottmp<- reactive({
    
    ## ggplot code
    (input$plot_type == "ggplot2")
    
    ggplot(tempdf(), aes(x=factor(gen),y=value)) +
      labs(title=paste0("Evaluation based on ", input$stereotype), 
           x="Gender",
           y=paste0("Stereotype of ", input$stereotype)) +
      geom_boxplot() + 
      theme_light()
  })
  
  ##### -- code for output from here
  
  # render plot for user 
  output$st <- renderPlot({
   
    plottmp()
  })
  
  output$act <- DT::renderDataTable({
    
    movietmp()
  })
}

# Run the application 
shinyApp(ui = ui, server = server)

Shiny apps have a user interface (UI) that is wrapped around code that runs in the background on a server.

When programming a shiny app therefore we need to program both the design (UI) and the code that runs on the server (server).

User Interface – UI

The UI part makes a shiny app attractive to the audience and, if programmed right, can engage the audience in an interactive and dynamic manner.

Programming the UI part requires a bit of orientation toward the audience for which the app is designed.

In the UI part, we need refer to objects from the server part.

If we do not call objects from the server in the UI part properly, the app might still work but the audience will not have access to it.

Take some time to decide what do you want to include in the app and what do you need for your audience.

For example, do you want the audience to view plots or tables, and if yes, do you want these to be interactive?

What code do you need to write on the server part and what is the final r object that you’d want to be displayed for the audience via the UI?

Layout

sidebarPanel

sidebarPanel() wrapped inside the sidebarLayout() because it is just one element of several that can be placed on the sidebarLayout of the app.

The attributes defined here are fed into the code on the server, so make sure you chose the appropriate user input type.

    sidebarLayout(position = "left",
                  
        sidebarPanel(
          
          # actor input
          selectInput("actor",
                      label="Choose an actor:",
                      c("Keanu Reeves",
                        "Alec Baldwin",
                        "Arnold Schwarzenegger",
                        "Timothee Chalamet",
                        "Anamaria Marinca"),
                      multiple = TRUE), 
          
          ...

mainPanel

mainPanel() contains the output, be it plain text, live text, tables or figures.

If in the sidebarPanel() you define the user input attributes, in the mainPanel() you simply call the objects computed on the server and programm how exactly will they be displayed.

mainPanel(
          
          h3("Output displayed here",),
          # start tabset Panel
          tabsetPanel(
            
            # tab 1
            tabPanel("Actors",
                     
                     tags$p(HTML(paste("A table is generated based on the actors chosen on the side panel..", sep = "")) ),        
                     
                     DT::dataTableOutput("act") ),
            
            # tab 2
            tabPanel("Stereotypes",
                     
                     tags$p(HTML(paste("A plote is generated based on the variable chosen on the side panel..", sep = "")) ),
                     
                     plotOutput("st") )
            ...

Outcome app

Input types

See shiny gallery for a comprehensive list https://shiny.posit.co/r/gallery/.

Sidebar code

sliderInput(inputId = "bins",
            label = "Number of bins: ",
            value = 1,
            min = 1,
            max = 100)

How it looks

select

Code

selectInput(inputId = = "actor",
            label = "Choose an actor:",
            choices =  c("Keanu Reeves",
                        "Alec Baldwin",
                        "Arnold Schwarzenegger",
                        "Timothee Chalamet",
                        "Anamaria Marinca"),
                      multiple = TRUE)

How it looks

checkbox

checkboxInput(inputId =  "p1.ess",
              label = "Distribution", 
              value = F)

How it looks

numeric

Code

numericInput(inputId = "numinp",
             label = "Number of obs",
             value = 100,
             min = 10,
             max = 999,
             step = 5)

How it looks

Conditional panels

There might be situations where you’d want to create a conditional user interface.

The UI experience can, at some pre-defined parts, be conditional on user input.

conditionalPanel( 
            condition= "input.type=='Simulations'",
... # the code continues here with input values

How it looks

Tabset

There can be situations where it is helpful to organize output into separate panels – similar logic to having several tabs open on your web browser.

tabsetPabel(
  tabPanel1("label 1 for display to user", {content 1 here}),
  tabPanel2("label 2 for display to user", {content 2 here})
)

How it looks

Code for server

The code for the server is a custom function, a very large and complex one but, still a custom function.

Input and output arguments

The server function takes two arguments:

input signals what comes from the UI interface. That is, what the user of the app is inputing via the UI.

output signals what goes from the server to the UI. That is, what the user views as a result of interacting with the app.

Reactive objects

Plain R code wrapped inside an object that the server needs to compute.

Reactive, because the server has to first compute it before performing any tasks that call on it.

Objects created on the server are reactive to code that requires them.

Code for the server

Needs to be written inside ({YOUR SERVER CODE HERE}).

It is a specific code chunk for the server.

# data from Stanciu et al. 2017
  
  tempdf <- reactive({
    # define the input object for data manipulation
    choice=input$stereotype
    
    # takes the loaded data (a step not shown here)
    # then, manipulates the data
    # note that the output was not assigned to an object in the code
    # the output is assigned to the reactive object "tempdf()"
    dfex %>% 
      sjlabelled::remove_all_labels() %>% 
      pivot_longer(contains("warm") | contains("comp")) %>% 
      filter(name %in% choice)
  
  })

Input objects

Reactive objects that take user input to generate output through code on the server.

# data from Stanciu et al. 2017
  
  tempdf <- reactive({
    # define the input object for data manipulation
    choice=input$stereotype
    
    # takes the loaded data (a step not shown here)
    # then, manipulates the data
    # note that the output was not assigned to an object in the code
    # the output is assigned to the reactive object "tempdf()"
    dfex %>% 
      sjlabelled::remove_all_labels() %>% 
      pivot_longer(contains("warm") | contains("comp")) %>% 
      filter(name %in% choice)
  
  })

 # UI code for stereotype input  
          selectInput("stereotype",
                        label="Stereotype dimension:",
                        c("Warmth women" = "wom_warm",
                                  "Competence women" = "wom_comp",
                                  "Warmth men" = "men_warm",
                                  "Competence men" = "men_comp"))

Output objects

Output objects are the output that we want to be displayed on the user interface.

This means that we have to call it as such and indicate the position where we want it displayed.

Ideally, we have already coded the display position and display characteristics in the UI code.

Output objects

plotOutput("st")

# generate ggplot
plottmp<- reactive({
    
    ## ggplot code
    (input$plot_type == "ggplot2")
    
    ggplot(tempdf(), aes(x=factor(gen),y=value)) +
      labs(title=paste0("Evaluation based on ", input$stereotype), 
           x="Gender",
           y=paste0("Stereotype of ", input$stereotype)) +
      geom_boxplot() + 
      theme_light()
  })

# render plot for user 
  output$st <- renderPlot({
   
    plottmp()
  })

Output objects

When coding output objects, these need to be wrapped inside designated code chunks – for plots or tables or text.

See this official cheetsheet https://rstudio.github.io/cheatsheets/html/shiny.html.

Run the app locally

Running the app locally is as simple as pressing the button Run App.

This is in fact calling a function written inside the app.R script.

This function is shinyApp(ui = ui,server = server).

Available only on the local machine.

The shinyApp() function takes two arguments ui and server that are defined separately.

Running the app, a new window will open. You might note two things in the console:

1. The console is busy with the app, as indicated by the STOP symbol.

2. The text in the console Listening on {an IP address}.

Deploy online the app

We would need a dedicated server and, of course, an access account on that server.

One efficient and smooth way to deploy a shiny app online is to use the dedicated server https://www.shinyapps.io/.

If you haven’t one, please open an account on https://www.shinyapps.io/.

Deploying the app might take some time but once done, the app will automatically open in your web browser.

GitHub (optional)

One further thing we might want to do is to push the script files to GitHub. This, if we are working collaboratively or if we want the code to be publically available.

University of Luxembourg shiny server (optional)

As of April 2026, the University of Luxembourg has a functional shiny-server.

This hosting server is GDPR conform as everything is stored on the premises of UL.

A list of currently available apps hosted at UL can be found on the dedicated page: https://shiny-uni.uni.lu/

To deploy a shiny-app on this server:

1. Make sure you have an account on UL GitLab (open an IT ticket if not)
2. Get in touch with me (admin) to give you deployment rights
3. Push your repository to UL GitLab project shiny-uni
4. The server will automatically render the app and index it on the dedicated shiny server page

Note: Before you deploy your website, please send me a list of all r packages needed for your app. These packages will be installed for you on the server directly.

Advanced resources

Shiny apps can be programmed in quarto as well.

Follow the steps here https://quarto.org/docs/interactive/shiny/.

Coding a shiny app inside a quarto document makes your work environment more structured.