Forem: ThinkR

What's a "successful" Shiny Application?

Colin Fay — Wed, 10 Jun 2020 19:12:12 +0000

One of the things that we keep promoting in the ThinkR team are good practices for production software engineering in R. Of course, that implies Shiny Applications—and even more if we introduce the {golem} package, which promotes good practices for "production-grade" Shiny application.

But let's take a step back and think about what makes a successful/production-grade Shiny Application.

It Exists

That seems like an obvious concept, but of course a Shiny application is successful and ready for production if the dev team was able to move from the idea to the actual implementation to the delivery of the app. It's a very 'engineer-oriented' definition of success, but that's a pragmatic one: a project that doesn't exist can't be labelled as a successful one.

And when it comes to a Shiny Application (or to any web application), the fact that an application exists means that the team has been able to organise itself in an efficient manner, so that they could work together on making this application a success. Anybody that has already worked on a code base as a team knows it is not an easy task.

Working in a framework like {golem} does help you reaching this goal: working inside a formalised structure will help you keep track of what is happening, and allows to grasp more easily what is contained in a given project. For example, if I today open a {golem} project I have never seen before, I will immediately be able to understand how the codebase is organised.

It's Accurate

Once the application exists, the other parameter that defines a production-grade application is that it is accurate. In other words, the visualisation are correct, the algorithms return the answer they are supposed to, the information are the needed one, etc.

And yes, it happens that you deliver an application that works differently from the way it is expected to work. How do we prevent from that? First of all, by applying the "separation of concern":

Business logic should be strictly separated from the application logic: build the back end and the non interactive functions separately from the interactive elements, work on them, validate them, and only once everything is thoroughly tested you can start integrating both together.
Build a strong and reliable testing suite, so that you can catch any bug that will come along your project.

If you use {golem} and the general philosophy that comes with it, that is something you will be applying from the very beginning: separate everything, build the business logic and the UI, organise everything in files, and of course, as you'll be using the package structure, use widely used testing frameworks.

It's Usable

Your application exists, it's accurate, but now you should get sure it's usable—in other words, your audience should visit the app and find it user-friendly. And if these people cannot use the application because it is too hard to use, too hard to understand, because it is too slow or there is no inherent logic in how the user experience is designed, then it is inappropriate to call the app a success.

It's Immortal

Of course nobody expect your app to live forever, but that's what you should reach for: robustness along the years.

Planning for the future is a very important component of a successful Shiny App project. Once the app is out, it is successful if it can exist in the long run, with all the hazards that this implies: new package versions that could potentially break the code base, sudden call for the implementation of new features in the global interface, changing key features of the UI or the back-end, and not to mention passing the code base along to someone who has not worked on the first version, and who is now in charge of developing the next version . And this, again, is hard to do without effective planning and efficient engineering.

Learn to Build a Production-Grade Shiny App

If you're interested in getting trained on building production-grade Shiny applications, we will be giving a remote training session in July.

It will be a 10 half-day session, fully remote, on our online e-learning platform!

And good news, you can get certified "Shiny Developer" at this end of this session.

Registration and more information are available here

Learning Shiny for Production – Remote session

Colin Fay — Wed, 20 May 2020 19:18:53 +0000

Learning Shiny for Production

Hello world!

We're very happy to announce that we will be giving a remote training session on building Shiny Application for production in July. Be quick, we only have 10 spots available!

Shiny for Production

Program

Introduction to `{golem}`

Introduction
The {golem} framework
- Presentation
- General philosophy
- Understanding a {golem} application structure
- Starting and configuring a {golem} application
Package development in the context of {golem}
- Using dependencies
- Documentation
Project: Starting and configuring a {golem} application. Adding a basic UI/server logic.

Prototyping an application

UX/UI best practices
Prototyping a Shiny Application
- The {shinipsum} package
- Introduction to {fakir}
- Defining the business logic in Rmd
Project: Building a prototyped application with {shinipsum} and {golem}

Shiny Modules

Shiny modules
- Why shiny modules?
- Building modules
- Sharing data accross modules
Project: Building an application with Shiny Modules

Reactivity

Reactivity best pratices
- Refresher on Shiny Reactivity
- Reactivity: the good, the bad, the ugly
- Safely manage reactivity in a Shiny application

Introduction to JavaScript for Shiny

JavaScript for Shiny
- What is JavaScript
- Using {golem} JavaScript functions
- Introduction to custom JavaScript
Project: Integrating basic JavaScript in the application

Deployment

Where to deploy
- Overview of available deployment methodologies
- Strength and weakness of each method
Preparing the app for deployment
- Overview of Shiny testing
- Introduction to CI/CD
Project: Add content to the Shiny Application and prepare it for deployment.
Project: Deploy your application

Note: All the modules will be coupled with exercises. Attendees will be building an application all along the training, and will deploy it on the last day.

Exam

This workshop can be validated with an exam. If you pass this exam, we will send you a Shiny Developer certification.

How to apply? Once the workshop is finished, you will have one month to build a Shiny application that follows all the practices from this training. You'll then put this application online (at least available to us), and share the source code. We will then set up a 30 minutes call for you to present us your application.

Who is this training for?

We expect the attendees to be at least familiar with {shiny}, i.e. to either have built one or more application(s) or to have collaborated on one or more {shiny} application(s). Attendees should also know the basics of package development, even if we will briefly cover packages on the first day.

Requirements:

General knowledge of shiny basics
How to create functions
Basic knowledge of package development

Two extra tickets will be dedicated for attendees from under-represented groups and/or with financial difficulties. If you consider you are eligible, do not hesitate to specify it in the form below. We will get back to you with more information about the application process.

Logistics

🗺 Where? Online!
💻 How? ThinkR provides a pre-configured web platform specifically designed for remote trainings in R
🤒 Which conditions ? Tutorial is provided for a small group to provide the best possible experience. See "Our vision of remote trainings and certification".
👨‍💻 Who? Colin Fay (@_ColinFay). Teaching assistants: Sébastien Rochette, Vincent Guyader, Cervan Girard, Margot Brard.
💻 What do I need? The training will be given online. We'll send you the details about how and where to log a few days before it starts.
💵 How much? The full training is $4000 (3600€) for the 5 days.
⏳ When? The workshop is divided in 10 sessions of 3,5 hours. They will happen on the following days:
- 2020-07-01
- 2020-07-02
- 2020-07-03
- 2020-07-08
- 2020-07-09
- 2020-07-10
- 2020-07-15
- 2020-07-16
- 2020-07-17
- 2020-07-20

Each session is scheduled on the following time slot:

02.00PM - 05.30PM Paris time : lubridate::ymd_hm("2020-07-01 14:00", tz = "Europe/Paris")
9.00 AM - 12.30PM New York time : lubridate::ymd_hm("2020-07-01 09:00", tz = "America/New_York")

Goodies

Each attendee will receive:

{golem} stickers
{golem} cheatcheets
A paper copy of the "Engineering Production-Grade Shiny Apps" book (once available in print)

Register

Please go to https://rtask.thinkr.fr/remote-trainings-and-certification/learning-shiny-online-july/ to register

Shiny for Production - Advanced

We're also planning on doing an advanced Shiny for Production online training, but we haven't decided on a date yet. This session will cover the following topics:

Best practices for production
Testing Shiny front-end, back-end, and load capacity
Parallelization & Asynchronicity
Optimization
Advanced deployment
Advanced JavaScript for Shiny

We haven't chosen a date yet, enter your mail below if you want to be the first to be informed!