What is Shiny about Shiny APP?

Shiny app is available here, and the source code is on the GitHub

In the world of Data Science, R programming language has emerged as one of the most powerful tools. Imagine taking your analyses to a whole new level with interactive communication with data and results—that's precisely what Shiny applications offer. Shiny, a free package for the R programming language, is tailored to create interactive web applications, enabling users to explore and manipulate data in real time. These applications utilize R as the backend, providing the capability to conduct analyses, generate graphs, and build statistical models, all while presenting the results in a user-friendly and interactive manner.

Building applications is very straightforward and does not require a deep understanding of web programming. Applications have two main parts: the user interface (UI) and server logic. The UI defines how the application will look and how users will interact with it. UI elements can include graphical elements (charts, tables, images, etc.), forms and input elements (text fields, buttons, drop-down menus), layout, and styling (arrangement of elements, colors, fonts). Server logic defines how the application will respond to user interactions, process data, and update the user interface. Server logic elements include functions for data processing (calculation, filtering, data visualization), response to user actions (tracking changes in inputs, buttons, etc.), and updating the UI (dynamic updating of charts, tables, text).

Let's create a simple Shiny app in RStudio using the built in mtcars dataset, which provides informations on various car characteristics. This app will enable users to explore and visualize data interactively.

Here's how you can get started:

1. If you haven't already, download and install R from the official R project website. Visit the website, select a mirror close to you, and choose the appropriate operating system (Windows, macOS, Linux). Follow the provided instructions for downloading and installation.

2. Once R is installed, proceed to download and install RStudio. RStudio is an Integrated Development Environment (IDE) for R, designed to simplify working with the R language. Find the suitable version for your operating system on the website, and follow the provided instructions for installation.

3. After a successful installation, launch R Studio. This will open a window with the console, script editor, and environment, allowing you to start building your Shiny application. Create a new R script.

The following step involves installing (if not already done) and loading libraries, and data. Once completed, we can proceed to define the UI and server logic.

# Installing packages
install.packages("shiny")
install.packages("ggplot2")

# Reading libraries
library(shiny)
library(ggplot2)

# Importing mtcars dataset
data(mtcars)

# Defining UI
ui <- fluidPage(
    titlePanel("Shiny Aplikacija mtcars"),
    sidebarLayout(
        sidebarPanel(
            selectInput(
                inputId = "x", 
                label = "Odaberi x-osi:", 
                choices = names(mtcars), 
                selected = "mpg"),
            selectInput(
                inputId = "y", 
                label = "Odaberi y-osi:", 
                choices = names(mtcars), 
                selected = "hp")
        ),
        mainPanel(
            plotOutput(
                outputId = "graf")
        )
    )
)

# Defining server logic
server <- function(input, output){
    output$graf <- renderPlot({
        ggplot(data = mtcars, 
               aes_string(x = input$x, y = input$y)) +
        geom_point() +
        labs(title = paste("Scatterplot of", input$x, "vs",                                                     
             input$y))
    })
}

# Running Shiny app
shinyApp(ui = ui, server = server)

fluidPage function creates a fluid page, meaning that the elements on the page adapt to the size of the browser window. Fluid pages enable responsive UI that adjusts to the screen size. titlePanel function creates a title bar at the top of the page. Here, you can set the title or any other content you want to display at the top of your application. sidebarLayout is a function that allows you to set up the interface structure with a sidebar and the main part of the page. The sidebar often contains input elements such as dropdown menus, buttons, etc. sidebarPanel function creates a sidebar within sidebarLayout. Here, you can place various input elements that allow users to interact with the application, such as dropdown menus, buttons, or sliders. selectInput enables the creation of interactive dropdown menus in the user interface of the application. This function has several arguments that allow customization of the appearance and behavior of the dropdown menu. inputId defines a unique identifier for the dropdown menu used to identify the user's choice and connect it to the appropriate data in the server logic. label sets the text to be displayed above the dropdown menu. choices is a vector containing the options that the user can select in the dropdown menu. These options can be strings, numbers, or factors. selected allows setting the initial choice in the dropdown menu. mainPanel is a function that creates the main part of the page within sidebarLayout. Here, you can place the content you want to show to users, such as graphs, tables, text, etc. plotOutput is a function that reserves space on the page to display graphical elements generated by server logic. For example, if you want to display a chart, you would use plotOutput in mainPanel and then use server logic to generate and update the chart.

The server logic manages user interactions, generates data, and updates the UI. To define the output displayed in the UI, we use output$, where the name after the $ indicates the output identifier. For instance, output$plot refers to the output identified as "plot". The renderPlot function takes R code, generates a plot, and displays it in the UI.

shinyApp function is a fundamental component. It is used to combine the UI and server logic, creating a complete Shiny application that can be run and deployed.

After writing our Shiny application in R script, it should be saved as app.R. Naming the file as app.R allows RStudio to recognize it as a Shiny application automatically configuring the "Run App" button in the top right corner. Activating this button permits you to directly execute the Shiny application from RStudio. If the code is correctly written, pressing the button will showcase your app in the bottom right window.

Congratulations! You have just built your first Shiny app and opened the door to the world of interactive data analysis and visualizations in the R programming language. Despite the simplicity of this application, it represents a step into the incredible realm of Shiny possibilities.

You've seen how easily you can integrate user input elements and generate a plot based on those input values. This is just a small introduction to the basics of building Shiny applications. If this simple application has inspired you, know that Shiny offers much more. You can add more inputs, graphical elements, pages, and even incorporate more complex functionalities such as interacting with databases or creating dynamic reports.

For further learning and exploration, visit the official Shiny website, where you can find a rich source of content, documentation, and examples. We also recommend exploring Shiny demo applications available on the site, which provide inspiration and showcase a wide range of possibilities. Additionally, the book "Mastering Shiny," available online, is an excellent guide and introduction to the world of building Shiny applications. Through clearly structured lessons, the book guides you from a novice in application development to the status of an expert programmer capable of writing large and complex Shiny applications.

One of the numerous possibilities offered by Shiny applications is their implementation by hosting on a server, making them accessible on the web, and allowing access to anyone with an internet connection. Shiny applications can have their own domain, adapt to your brand or specific needs. Setting up your own domain further contributes to a professional appearance and enables users easy access to your analyses.

Applications can be used in various domains and industrial sectors. In the financial sector, they can be utilized for real-time market monitoring, interactive financial reporting, and portfolio analysis. In medicine, applications enable the creation of tools for medical diagnostics, monitoring vital signs, and generating interactive medical reports. In marketing, they facilitate market analysis, targeted audience segmentation, and visualization of marketing data. Scientists and data analysts can use Shiny for visualizing, analyzing, and sharing the results of their research. Shiny applications can be employed for monitoring and analyzing sensor data, such as air quality, water quality, or energy data, as well as in many other domains.