Introduction

Shiny is an open-source web application framework for R that allows users to create interactive dashboards and web applications with minimal effort. This course is designed to guide participants through building dynamic, interactive data visualizations and dashboards using Shiny, from the basics to advanced techniques. Participants will learn how to create applications that can handle real-time data, interact with users, and allow for customized visualizations. By the end of the course, participants will have the skills to develop fully interactive web applications tailored to their data needs.

Objectives

By the end of this course, participants will:

• Understand the fundamentals of Shiny and its core components: UI, server, and reactive elements.
• Learn how to design and develop interactive dashboards with Shiny.
• Integrate dynamic data visualizations (e.g., interactive charts, maps) into Shiny applications.
• Implement advanced features like real-time updates, reactive inputs, and user-driven filtering.
• Learn best practices for deploying and optimizing Shiny applications for production.
• Gain hands-on experience in building and deploying interactive dashboards for data-driven decision-making.

Who Should Attend?

This course is ideal for:

• Data scientists, analysts, and R developers who want to create interactive dashboards.
• Professionals who want to integrate data analysis and visualizations into web-based applications.
• Business intelligence professionals looking to build data-driven reporting tools.
• Anyone interested in using Shiny to create interactive data visualizations and dashboards with R.

Day 1: Introduction to Shiny and Dashboard Fundamentals

Morning Session: Getting Started with Shiny

• Introduction to Shiny: What is it and why is it useful for interactive dashboards?
• Overview of Shiny components: UI, server, and reactive expressions
• Shiny app structure: UI (user interface), server logic, and interaction between components
• Setting up a basic Shiny app: Building a simple application with input and output elements
• Hands-on: Create a basic Shiny app displaying static outputs (e.g., text, tables)

Afternoon Session: UI Layouts and Basic Interactivity

• Designing user interfaces in Shiny: Layouts, panels, and controls
• Adding input controls: sliders, select boxes, and checkboxes
• Displaying dynamic outputs: Tables, plots, and text updates
• Introduction to reactive programming in Shiny: How inputs influence outputs
• Hands-on: Building a dynamic application that reacts to user inputs

Day 2: Working with Data and Visualizations

Morning Session: Data Handling in Shiny

• Importing and cleaning data for Shiny applications: Using R libraries (e.g., dplyr, tidyr)
• Reactive data: How to update data reactively based on user inputs
• Loading large datasets efficiently for Shiny apps
• Hands-on: Creating an app that loads and manipulates data based on user input

Afternoon Session: Adding Interactive Visualizations

• Integrating ggplot2 for static and interactive visualizations in Shiny
• Using plotly to add interactivity to ggplot2 charts
• Creating interactive maps with leaflet in Shiny applications
• Implementing interactive visual elements: Zoom, tooltips, and hover effects
• Hands-on: Build an interactive data visualization dashboard using ggplot2 and plotly

Day 3: Advanced Features and Dynamic Updates

Morning Session: Advanced Shiny Features

• Customizing app appearance with CSS and HTML
• Using shinydashboard to create polished and user-friendly dashboards
• Handling real-time data updates: Using reactivePoll and dynamic outputs
• Managing session states and user inputs in complex applications
• Hands-on: Create an advanced dashboard using shinydashboard and plotly

Afternoon Session: Real-Time Data and User Interactions

• Real-time updates with reactivePoll and WebSockets: Building applications that refresh automatically
• Creating responsive inputs: Dropdowns, date selectors, and range sliders
• Implementing real-time filtering and searching features for data
• Hands-on: Build an app with real-time data updates and interactive user-driven filtering

Day 4: Deploying and Optimizing Shiny Applications

Morning Session: Deployment Strategies

• Introduction to Shiny Server and ShinyApps.io for app deployment
• Hosting Shiny apps on cloud platforms (e.g., AWS, DigitalOcean)
• Securing Shiny apps: User authentication and access control
• Best practices for deploying Shiny apps to production environments
• Hands-on: Deploy a Shiny app to ShinyApps.io and manage app access

Afternoon Session: Optimizing Shiny Apps for Performance

• Optimizing Shiny applications for large datasets and complex visualizations
• Reducing latency and improving responsiveness with caching and lazy loading
• Debugging and troubleshooting common performance bottlenecks
• Hands-on: Optimizing an app for faster performance and responsiveness

Day 5: Final Project and Advanced Techniques

Morning Session: Advanced Shiny Techniques

• Advanced user interface customizations: Using shinymaterial and shinyjs
• Custom components and libraries for building sophisticated apps
• Handling complex layouts: Multiple pages and dynamic navigation
• Integrating Shiny apps with external APIs and data sources (e.g., databases, cloud storage)
• Hands-on: Build a complex, multi-page Shiny app with custom UI elements

Afternoon Session: Final Project and Course Wrap-Up

• Final project: Participants will build a complete interactive dashboard, incorporating:
  • Dynamic visualizations (e.g., plotly charts, leaflet maps)
  • Real-time updates and user input interactivity
  • Data manipulation and filtering based on user interactions
• Final project presentations and feedback
• Wrap-up: Key takeaways, future learning paths, and advanced resources for continued Shiny development

Materials and Tools:

• Required tools: R, Shiny, ggplot2, plotly, leaflet, shinydashboard, shinyjs
• Sample datasets: Public datasets (e.g., sales data, population data, environmental data)
• Access to example code and templates for building Shiny applications
• Recommended resources: Documentation for Shiny, plotly, leaflet, shinydashboard