
What this course is about - we present the course goals and structure here.
Let's see how our final product will look - what our app does and how it looks. This way we know exactly what we have to do.
Here we talk about user interface and server, the main parts of any Shiny application.
A template that you can use as a starting point for any app you build.
How to use rows and columns to organise the elements in our app interface.
Time to do some coding now. Let's quickly build a grid layout for our user interface.
Here we get to know all the input controls that allow users to interact with a Shiny app.
Let's create the input controls that we need in our app.
In this PDF file you can find the details about each Shiny input. Use it as a reference document any time you need to create inputs.
Here we introduce some special functions hep us create placeholders for our output objects.
Time for some more coding. Let's position the output placeholders in their exact locations.
Let's learn something more about the server function arguments: input and output.
Now we can talk about the exact procedure that Shiny uses to generate outputs.
So, what exactly is reactivity? And what is laziness?
Shiny inputs and outputs can be manipulated in a reactive context only. That's why it's crucial to understand what reactive context is, and how we can create it.
Learn a very important type of functions that generate reactive context.
Another function that creates reactive context. We will need it in our app, so we must know how to write it.
so, let's see what tasks our server function must perform, exactly.
First, we must do some data wrangling with dplyr. Let's see how to do that inside a reactive context.
Let's produce our first output object: the text block.
Now we write the code to display our interactive table.
Final operations: plot the bar chart and the pie chart.
Let's see an app that does something really useful: predicts customer attrition. It's based on real world data, of course.
Let's look behind the curtain and see how the app is written and how it works.
In this Shiny tutorial you will learn the fundamentals of Shiny programming and, more important, you will build your first shiny app, starting from zero. So even if you have no experience with shiny right now, when you finish this tutorial you will be able to start building simple shiny applications.
So, let’s see what you are going to learn in this course.
In the second section of the course, before getting into stuff, we review the app that we are going to build. This way you will have a clear idea about our goal. You can refer to this section at any time – while learning – to see what you have done until that moment and what remains to be done.
In the third section we’ll clarify the main Shiny concepts. We’ll talk about the big components of any Shiny app – user interface and server – and we’ll explain their role and function. Then we’ll present the basic shiny app template – you can use this template as a starting point for any app that you’ll build in the future.
In the next section we’ll build a neat layout for our app. We cannot enter into advanced layout techniques , but we’ll still create a grid layout to organise the app elements in the page and make the user interface good-looking.
The fifth section is about creating input objects. The inputs are the elements that allow the user to interact with the app. You’ll learn how to write input objects using shiny code and we’ll create the inputs that we need in our app.
The sections six and seven are about the outputs. First, we’ll learn about output placeholders – some special functions that indicate the type and place of each output object in the user interface. You will be acquainted with the output objects that the shiny program can build – text, tables, charts and images. Furthermore, you will learn the exact procedure that shiny employs for creating outputs.
After learning about the user interface elements, you must understand how the server function works. But first you must grasp the concept of reactivity. The section number eight is dedicated to this topic. Here we define reactivity and explain the crucial concept of reactive context. To manipulate variables in Shiny we absolutely need to generate reactive context. That’s why we’ll learn a few functions that do exactly that. Everything is presented in detail in section eight.
When you become familiar with reactivity, you are able to write the server part of you application. This is what we are going to do in the last section of the course. We will learn how to manipulate data in a Shiny environment (that is, in a reactive context), how to print text in the user interface, how to create and display an interactive table, how to build charts in shiny using the ggplot2 package.
At the end of this section, our app will be completely functional.
There is also a bonus section, where I shortly present a more complex app and explain a little bit how it works. This way you’ll realise better the possibilities and capabilities of the Shiny package.
Enrol today and start your journey to becoming a Shiny expert!