In the first edition of this book, which was based on Shiny 0.6, we described only two types of application. First, a fairly simple Bootstrap-themed interface with input widgets down the left and output (a single page or a tabbed output window) on the right. The second type consisted of custom-built web pages with their own HTML and CSS files. Shiny has developed quite a bit since then, and there are actually many types of Shiny application and many ways of building them. These are as follows:

• Interactive markdown documents with Shiny widgets embedded
• Shiny applications (default CSS, written entirely in R)
• Web pages (for example, custom CSS, HTML, and JavaScript)
• Shiny gadgets
• Flex dashboards

In this chapter, we will be considering the first two: interactive documents and full applications. Chapter 3, Integrating Shiny with HTML, will cover how to...

The first thing to note is that Shiny programs are the easiest to build and understand using two scripts, which are kept within the same folder. They should be named server.R and ui.R.

The ui.R file is a description of the UI, and is often the shortest and simplest part of a Shiny application. In the following code, note the use of the # character, which marks lines of code as comments that will not be run, but which are for the benefit of the humans producing the code:

fluidPage(                                 # Line 1 
  titlePanel("Minimal application"),       # Line 2 
  sidebarLayout(                           # Line 3 
    sidebarPanel...

Before we move on to a more advanced application, let's have a look at the main widgets that you will make use of within Shiny. I've built a Shiny application that will show you what they all look like, as well as their outputs and the type of data they return. To run it, just enter the following command:

> library(shiny)
  runGist(6571951)

This is one of the several built-in functions of Shiny that allow you to run code hosted on the internet. Details about sharing your own creations in other ways are discussed in Chapter 9, Persistence, Storage, and Sharing. The finished application looks like the following screenshot:

You can see the function names (checkboxGroupInput and checkboxInput) as numbered entries on the left-hand side of the panel; for more details, just type ?checkboxGroupInput into the console.

If you're curious about the code, it...

Now that we've got the basics, let's build a full application. Before we proceed, note that we will need to install a few packages—tidyverse, gapminder, leaflet, and ggmap. Each can be installed from CRAN (the official R package repository) using the code phrases install.packages("tidyverse"), install.packages("gapminder"), and so on. We will not install ggmap this way, though. At the time of writing, there is a bug in the CRAN version. We'll install the dev version instead, as shown in the following code:

install.packages("devtools")
library(devtools)
devtools::install_github("dkahle/ggmap")

The application is pretty simple to get us started, but it illustrates several important methods and principles in Shiny. It features tabbed output, which allows the user to select different inputs or groups...

In this chapter, we have covered the most simple of the layout features in Shiny with the help of the sidebarLayout(), mainPanel(), and tabsetPanel() functions. In later chapters, we will build larger and more complex applications, including dashboards, and make use of more advanced layout features. It is worth pausing here briefly to take a quick look at the other types of layout that are available so that you can think about the best way to implement your own application as we go through the next couple of chapters.

There are essentially two more broad types of layout function that you can use in Shiny. The first uses the layout features of Bootstrap and allows you to precisely define the layout of your application using a grid layout. Essentially, Bootstrap
asks you to define the UI as a series of rows. Each row can be further subdivided into columns...

In this chapter, we have covered a lot of ground. We've seen that Shiny applications are generally made up of two files: server.R and ui.R. You've learned what each part of the code does, including setting up ui.R with the position and type of inputs and outputs, and setting up server.R with the data processing functions, outputs, and any reactive objects that are required.

The optional exercises have given you a chance to experiment with the code files in this chapter, varying the output types, using different widgets, and reviewing and adjusting their return values as appropriate. You've learned about the default layout in Shiny, sidebarLayout(), as well as the use of mainPanel() and tabsetPanel().

You've also learned about reactive objects and when you might use them. There's more on finely controlling reactivity later in the book.

In the next...