Conference Program
Keynote Speakers
Winston Chang
Lessons and opportunities with Shiny
for Python
Colin Fay
Production is like ultra running: brutal, ungrateful, but worth every step
Veerle van Leemput
Say goodbye to unnecessary waiting: mastering asynchronous programming in Shiny
Filip Stachura
Transforming Business with Open Source: Insights from the Pharma Industry
Three days of free, online Shiny content ranging from tips and tricks from the experts, to fascinating community case studies, and examples of enterprise scaling solutions.
Our program is packed with presentations, tutorials and panel discussions arranged in different categories – find your most desired topics and save your picks!
All times are CET (Central European Time) which is Coordinated Universal Time (UTC) +1 hour.
Live presentations are scheduled to overlap appropriate business hours for time zones across Europe, Africa, and the Americas.
- 03/15/2023
- 03/16/2023
- 03/17/2023
03/15/2023
2:00 pm - 4:15 pm
2:00 - 2:15 - Opening/Welcome
Damian Rodziewicz, Iwona Matyjaszek
Let's get this conference started! Opening remarks from Damian Rodziewicz - President at Appsilon and Iwona Matyjaszek - Sales Development Representative at Appsilon
2:15 - 2:45 PM - Sharing app state between Shiny modules
Marcin Dubel
One of the powerful features of Shiny is the ability to create modularised apps, where different parts of the app are organised into separate modules. That approach allows to avoiding code duplication and keeps the scripts simple. However, managing the state of a Shiny app that consists of multiple modules can be challenging. When using modules the purpose of the design should be to keep them as independent as possible. Yet modules are a part of the larger application and have to react to user actions in other modules. In this talk, we will explore different techniques for sharing app state between Shiny modules. We will discuss the use of global variables, reactive values, and custom modules for managing app state. We will also discuss best practices for debugging and testing Shiny apps with multiple modules. Finally, we will demonstrate how these techniques can be used to build more complex and scalable Shiny apps.
2:45 - 3:15 PM - GeNorms: An R Shiny App to Improve Gender Equitable and Social Values in Sub-Saharan Africa
Emmanuel Olamijuwon
The African Union Strategy for Gender Equality and Women’s Empowerment (2018-2028) aims to increase women’s empowerment in all spheres of life, from political to economic and social. However, harmful gender norms continue to hamper economic growth by denying millions of girls their right to education, jobs and opportunities to advance their health and well-being. This work represents part of a larger effort to track, model and address gender-equitable attitudes in African countries. We developed and deployed predictions from a machine learning algorithm to R-Shiny web application (GeNorms) to help individuals assess their gender attitudes as well as their intersection with other social values like religious tolerance, social cohesion, political values, social class and other relevant demographic characteristics. The GeNorms shiny app is based on Argon– a user-friendly and open-source dashboard based on Bootstrap 4. The app encompasses three unique modules and leverages several r-packages for data science and a package of UI helpers. First, we leveraged {leaflet} to visualise geographic patterns in gender equitable attitudes across three countries (Kenya, Nigeria and Zambia). We also used {shinysurveys} to collect user responses to predict their gender-equitable attitudes. Based on the predictions derived from the user responses, we provide additional information to help individuals with less equitable attitudes improve their knowledge and ultimately enhance their attitudes towards gender equality. Overall, our app has the potential to promote gender equitable norms across African countries while also challenging other harmful social norms.
3:15 - 3:45 PM - Why modules matter for new Shiny developers
Emily Riederer
R users are increasingly trained to develop with good principles such as writing modular functions, testing their code, and decomposing long individual scripts into R projects. In recent years, such approaches have crept earlier into introductory R education with the realization that applying best practices is not an advanced skill but rather empowers beginners with a more robust structure. However, new Shiny developers are confronted with two challenges: they must simultaneously learn new packages and concepts (like reactivity) which introductory tutorials demonstrate how to write their apps as single scripts. This means small changes are harder to test and debug for the groups that need it the most. Although Shiny modules offer a solution to this exact problem, they are regarded as an advanced topic and often not encountered until much later in a developer’s journey. In this talk, I will demonstrate a workflow to encourage the use of modules for newer Shiny users. I argue that a ‘module-first’ approach helps to decompose design into more tangible, bite-sized, and testable components and prevent the code sprawl that makes Shiny feel intimidating. Further, this approach can be even more powerful when developing Shiny applications in the enterprise setting and onboarding new team members to existing applications.
3:45 - 4:15 PM - ODAPES: A Low-Code Extension for R-Shiny to Democratize Digital Agriculture
Michael C Rubin
ODAPES’ Mission is to Democratize Digital Agriculture by giving all farmers, farming service providers and local cooperatives access to a low-cost, cutting-edge, and customized Digital Agriculture App . R-Shiny is the perfect tool for this task. However, despite this great package it is still a challenge to build customized, production-grade R-Shiny App at scale, because the needed R coding skills are not abundant . To address this challenge, we have developed a Low-Code Extension to R-Shiny, specific for ODAPES-Style Digital Agriculture Apps. This allows junior developers to create in a matter of hours production grade Apps with access to different microservices like API’s, GIS algorithms and RMarkdown reports. The system includes two parts: (1) A modular R-Shiny App-Skeleton, which allows to replicate, adapt, and customize a production-grade app. This part makes extensive use of Shiny modules, and Microservices and it includes 8 own R-packages. (2) A second R-Shiny App, called ApplicatoR, from which the Low-Code developer can customize the production App, including the stylesheet. This uses the packages DT, sortable and bs4Dash. The key of the system is a JS-binding for Shiny’s inputIds, which return intelligent information and makes the entire system modular and reproducible. The concept has already been successfully prototyped with clients across Latin America and developers from Venezuela, Brazil, Nigeria, and Chile, creating both affordable technology and local income opportunities.
Coffee Break I
No workshops in this session.
4:30 pm - 8:30 pm
4:30 - 5:30 PM - Shiny Dev Series Live with Eric Nantz
Eric Nantz with guests
In a special live recording of the Shiny Developer Series, host Eric Nantz will be joined by prominent members of the Shiny community (Tanya Cashoralli, Jon Harmon, Nicola Rennie, Pedro Silva, and Peter Solymos) to discuss topics such as their take on recent innovations in the Shiny ecosystem, lessons from creating complex applications, the future with Shiny in R and Python, and more!
5:30 - 6:15 PM - Transforming Business with Open Source: Insights from the Pharma Industry
Filip Stachura
6:15 - 6:45 PM - Mindfulness Break
Ewa Filipiak - Rokicka
- Introduction (5 minutes)
- A brief introduction to mindfulness and its benefits
- Mindful Breathing Exercise (5 minutes)
- Mindful Stretching (10 minutes)
- Mindful Walking (5 minutes)
- Gratitude Practice (5 minutes)
- Closing (5 minutes)
6:45 - 7:15 PM - What can I do to monitor and improve my Shiny App's performance?
Mohamed El Fodil Ihaddaden
A Shiny app comes many JavaScript/css dependencies, R developers tend to ignore this fact and use libraries that add other dependencies to this stack. In this context, a developer needs to think wisely which dependency is worth using. Furthermore, and in the R side, there are many techniques that allow one to develop a smooth and efficient application. For example, one can use more efficient packages, or load the data only when necessary and so on. Finally, when it comes to performance, the web offers a great amount of tools that allows one to monitor and improve the app's efficiency, we can easily mention the network tab in the devtools, the lighthouse, the performance API and many others.
7:15 - 7:45 PM - Which Sidewalks Should be Repaired?
Reid Haefer
As a city official or a member of your local public works department with a limited annual budget, out of all the sidewalks in your city, how do you decide which ones should be repaired? The city of Burlington, Vermont maintains 130 miles of sidewalks throughout their city which are all characterized by varying levels of disrepair – cracks, heaving, sloping, etc. In 2021, the city developed an innovative approach that employed an innovative data collection technology in conjunction with the creation of a custom, interactive webtool to prioritize sidewalk improvements throughout the city. Once the data was collected, the city developed a custom, web-based Shiny tool to explore the data and employ a system for prioritizing improvements. The custom webtool was built with a variety of features intended to support the city’s long-term vision of prioritizing sidewalk repairs with a limited budget into the future. Using this tool, the city can efficiently allocate their annual sidewalk repair budget to sidewalks in areas of their city that are the highest priority, based upon a variety of factors that include physical sidewalk condition, clustering of poor condition sidewalks, and characteristics of surrounding land uses, including equity considerations. Example tool features include user defined prioritization factors, web mapping, dynamic reporting, interactive plots, data management, and documentation.
7:45 - 8:30 PM - Roundtable: Innovating with Shiny and Large Language Models: Building Interactive Data Applications in the ChatGPT Era
Marek Rogala, Eric Nantz, David Keyes, Deepansh Khurana
Roundtable discussion with experts: Marek Rogala, David Keyes, Eric Nantz.
Moderator: Deepansh Khurana
8:30 - 9:00 - Open discussion table with Appsilon Team: Technical leadership challenges in Shiny
Pedro Silva
Join this networking/open discussion session moderated by Pedro Silva, Staff Engineer at Appsilon.
Everyone is welcome!
8:30 - 9:00 - 1:1 Networking
We invite you to use this time for making new connections in one-on-one meetings.
In the networking segment, when you click the Ready button, the system automatically pairs you up with someone else who has also clicked the Ready button. This match is paired randomly. If both parties are available, the two are matched instantly and the video chat begins.
You can also create 1:1 meetings with whoever you like. By going to the 'People' tab of the event, find the person you would like to connect with and click the invite to video call button.
8:45 pm - 10:00 pm
9:30 - 10:00 PM - moosecounter: A Shiny desktop application for adaptive moose surveys in the Yukon Territory, Canada
Peter Solymos
Managing wildlife populations requires knowledge about the distribution and abundance of species. To gather information needed to determine hunting quotas for Moose, the Yukon Government runs annual surveys. However surveying large areas with helicopters is costly ($2.5 M spent over the last decade), therefore, we developed an adaptive sampling design to get the most accurate population size estimates while being as cost efficient as possible. Adaptive surveys require biologists to analyze data daily which is then used to inform the next day’s flight route. Such analyses are conducted in remote areas and are best served by software with a straightforward GUI that does not rely on an unpredictable Internet connection. We first made an rJava based Deducer plugin, which became unmaintainable after R 4.0. Thus we turned the plugin into a Shiny app. In this talk I will share the evolution of the project over the last decade, how technology choices were made, and the impact these had on the Moose monitoring program. The Shiny app includes upload/download functionality to fit with the geospatial workflow. It contains steps for data exploration and modelling for total moose abundance and population composition (cows, calves, bulls). It also has options to scrutinize predictions and associated uncertainty, which in turn informs the survey design. Shiny has become an indispensable tool for bringing custom statistical workflows to a large scale field program. We hope our experiences and the open source software we created can help similar initiatives worldwide.
10:00 - 10:15 PM - Short summary of day one
Ian E Moore
Ian E. Moore - Technical Evangelist at Appsilon sharing insights from Day 1 of the conference
03/16/2023
2:00 pm - 3:45 pm
1:55 - 2:00 PM - Short welcome note
Ian Moore
Welcome to the day 2 of the conference, let's take a look at what we've prepared for you!
2:00 - 2:30 PM - Scaling Shiny: Experiences from building a large application in Pharma
John Coene
The shiny app enables a metadata driven approach to creating mock shells and Clinical Study Reports outputs at Idorsia. It aims to create a single point of access platform for a process that requires integrating multiple external components, streamlining the workflow and enabling statistical programmer to work more efficiently.
The talk is about the design considerations of building out this large app, examining how far Shiny can be stretched, and details some of the technical implications in integrating the different components that the app relies on. E.g. SAS Webserver, Database, S3 Bucket, Pinnacle 21, and others.
It is currently used in production on a pivotal phase 3 study. By the time this talk is live it will be used on 5 studies.
The application is relied upon by multiple people in a production environment whilst new features are constantly being added. It is therefore important to have readable and glanceable code so one can easily spot and address issues quickly.
We learned pretty early on to separate concerns into different packages, e.g. one wrapping a specific API, another to handle updates on data, push long-running processes in the background, etc.
These challenges were interesting to solve and worth sharing with the community.
2:30 - 3:00 PM - Creating a JavaScript Library for your Shiny Application
Ashley Baldry
You are comfortable writing JavaScript for your shiny applications, but the single script holding all of the JavaScript is becoming unmanageable, now what? Similar to R packages, JavaScript libraries can be built to hold all necessary code and bundled back into a useable script for the shiny application to use.
In this talk will discuss:
- how to set up a JavaScript library within an R package
- how to convert a single script into a library
- how to include the library in a shiny application
- the benefits of using a library over a single script
3:00 - 3:30 PM - Making Project Management Seamless using Automated Gantt Charts in R Shiny
Lucy Njuki, Yuanyuan Zhang
We are often involved in many projects as researchers in academia. Ensuring that we have the bigger picture of the project tasks can be challenging if not well documented. Recently, our line manager asked us to create a Gantt chart to present all current tasks and how far we are from completing them. R Markdown came to mind at first, and we created beautiful Gantt charts which can be shared as an HTML file. Since the projects are evolving, new tasks are assigned to us. Therefore, to present the updated Gantt chat, we ought to rerun the R Markdown file. A question came to mind. Instead of rerunning the R Markdown file to update the Gantt Chart, could Shiny Apps be used to automate this process? The answer is yes! We created an R Shiny App that can automate and update Gantt Charts. This results in improving the efficiency of project management in academia. In this presentation, we will point out some of the awesome features of R shiny and demonstrate how our R Shiny App can easily automate Gantt charts and track the progress of tasks.
3:30 - 4:00 PM - shinyGizmo - top features tutorial
Krystian Igras
When working with advanced Shiny applications, we often encounter non-standard problems for which the solution is not direct. There are many examples: disabling/enabling buttons in certain states of the application, collecting information from dynamic components or storing the modal dialog state are problems that may require us to know JS or advanced programming in R, and at the same time inefficiently use the resources of the application server. I face the above problems on a daily basis while creating complex applications. Generalized solutions have been collected in the shinyGizmo package, which I’ll present in my tutorial. The tutorial will cover the use of the following functionalities: - conditionalJS - generalized version of `conditionalPanel` to perform any JS operations directly from the UI level, - commonInput(s) - combining the values of many input widgets (also dynamic amount) into one, - modalDialogUI - UI-based version of modalDialog that keeps modal status for free, - valueButton - take any browser data to Shiny server. The use of each function and the reasoning for using it will be presented in the Shiny application, which at the end of the tutorial will be fully functional and built using best practices. More to that, as an extra part of the tutorial, I will present an interesting concept of creating Input Bindings based on other, already existing ones. This is the approach used in the pickCheckBoxInput component and I believe it will be of great interest to the more advanced Shiny developers.
4:00 pm - 9:45 pm
4:00 - 5:00 PM - Production is like ultra running: brutal, ungrateful, but worth every step
Colin Fay
Both production software engineering and ultra running are demanding and grueling. Both require extensive preparation, unwavering perseverance, and a determined mindset to overcome obstacles. Many times, it's tempting to take shortcuts or give up. Seasoned software engineers can attest to the difficulties in developing robust, scalable, and efficient software. The intricacies of code, project management, and infrastructure often result in long hours of work. And at the end of the day, a successful software codebase is entirely unnoticed by the end user. Ultra running works the same: hours of training and planning culminate in a successful race when the runner crosses the finish line. And during the race, the hours of training are invisible to the spectator. However, even if the hours of preparation are almost invisible, the journey and the experience gained are what make the effort truly fulfilling. In this talk, Colin will explore what ultra running has taught him about building production software and vice versa, and why approaching production work with the same dedication and passion as an ultra runner is crucial for success. He will highlight the importance of perseverance and the value of embracing challenges along the way.
5:00 - 6:00 PM - Data Science Hangout with David Granjon and Bo Wang
guest: David Granjon, Bo Wang
Please join us for this week's Data Science Hangout featuring David Granjon and Bo Wang, Senior Expert Data Science at Novartis. Join us to ask questions and hear how they provide their expertise to help associates design production ready apps for clinical trials, from wireframing activities to automated deployments.
First time joining a Data Science Hangout? What is it? It's a gathering place for the whole data science community - including current and future data science leaders - to chat about data science leadership and questions you're all facing that happens every Thursday at 12 ET .
There's no hard agenda or predetermined talk tracks: just an expert or two willing to share their perspectives on what’s really going on in data science at an organizational level.
As this is hosted by Posit, it is outside of the Hopin platform for the hour. You can join live using this link: pos.it/dsh-shiny and jump back into Hopin at the end of the hour.
☀️ All are welcome - no matter your industry/experience
🕶 No need to register
👌 It’s always okay to join for part of a session
🎤 You can listen-in, join-in the conversation, or ask questions anonymously
🗓 If you had fun today and want to add it to your calendar for future weeks: pos.it/dshYou can also check out recordings of past sessions on the Posit YouTube and Data Science Hangout site.
6:00 - 6:30 PM - Time to network!
6:00 - 6:30 PM - Open discussion table with Appsilon Team: Recruitment and cultural FAQs
Paulina Kaczmarczyk
6:30 - 7:00 PM - Introducing Rhinoverse
Jakub Nowicki, Kamil Żyła
7:00 - 7:30 PM - Securing your Shiny Dashboard
Colin Gillespie
Shiny apps, Rmarkdown reports and flask dashboards provide a rich user experience for relatively little development time. Often this experience is created by utilising third-party Javascript functions, CSS files, fonts and images, but every external file we use means we implicitly trust the authors. The NHS and thousands of other government websites can attest that this is an issue; in 2018, they ran scripts that made their visitors use their computing power to mine cryptocurrencies.
This talk will look at how organisations can improve their Shiny application security. We’ll discuss general procedures for securing your overall workflow, such as security audits of your R packages and general Git security. We’ll then see how Content Security Policies (CSPs) can be leveraged in Shiny apps, which allow a website to specify what external content a site can access. This talk will discuss implementing these precautions within Shiny and Posit Connect. We'll demonstrate that securing and monitoring your applications is relatively straightforward.
7:30 - 8:00 PM - Introduction to {teal} - open source framework to build interactive applications for clinical data analysis
Pawel Rucki & Dony Unardi
In this talk, we would like to present the {teal} package - built internally in Roche and now a fully open-sourced product with a focus on interactive clinical data analysis. Together with a series of other child packages, {teal} is equipped with features to elevate the user's exploratory experiences, such as data filtering, code reproducibility, logging, and report generator. Enriched with multiple complementary analysis R packages, users can get 50+ common analysis modules available for use. In addition, {teal} can provide R developers with a quick and efficient way to create customized shiny modules with different data types. In this talk, we will introduce the {teal} framework, highlight major features, and share how this has been implemented and adopted by thousands of data scientists in our organization. We will also present briefly the way how we achieved that as well as our efforts on open sourcing and collaboration within the pharma industry.
8:00 - 8:30 PM - Baking JavaScript into a Shiny Package
Jon Harmon
I'm not an expert in JavaScript, but I wanted to use cookies in my Shiny apps, and the easiest way to do that was to use the js-cookie JavaScript library. Once I got that working, I wrapped it into its own package, so that anyone (including future me) could easily use that library in future Shiny apps. I'll show how this effort led to the {cookies} package, which is now available on CRAN.
8:30 - 9:00 PM - Robotic Process Automation with Shiny (A Marketing Analytics Case Study)
Matt Dancho
Marketing Analytics is a $250,000,000,000 opportunity for companies. But few companies have the data science talent to make it happen. In this presentation, I'll show a powerful use case for Robotic Process Automation (RPA) using Shiny to help Marketing Analytics teams segment customers faster and more accurately, leading to better customer segmentation and up to a 10% increase in revenue.
9:00 - 9:45 PM - Roundtable: Empowering diversity in R (Shiny)
Mouna Belaid, Megan Rogers, Tresna Tanesya, Cosima Meyer, Emi Tanaka, Shel Kariuki
9:45 - 10:00 PM - Short summary of day 2
Ian E Moore
Ian E. Moore - Technical Evangelist at Appsilon sharing insights from Day 2 of the conference
03/17/2023
Third Day - Opening Segment
1:55 - 2:00 PM - Short welcome note
Ian Moore
Welcome to the day 3 of the conference, let's take a look at what we've prepared for you!
2:00 - 2:30 PM - How to build user-centric applications?
Anna Skrzydło
2:30 - 3:00 PM - Shiny Semantic in Shiny for Python
Pavel Demin
Shiny Semantic in Shiny-for-Python is an early attempt to contribute to the emerging Shiny ecosystem in Python. We used our experience with the shiny.semantic package for R/Shiny to implement its counterpart in another programming language.
During our development process we had an opportunity to experiment with different approaches to the overall package design. These approaches boil down to a simple statement: “I want my package to make the most sense from the perspective of … “ – (1) shiny.semantic implementation in R, (2) the underlying Semanti UI library, (3) PyShiny implementation.
During the talk, I plan to elaborate more on these approaches, how they appeared and how they changed each other naturally. I will also cover the following topics:
How we were able to reuse ideas and code from the existing shiny.semantic package
Why porting a UI components library from R to Python is much less painful than it could be
How does Rhino experience help in writing Python code
3:00 - 3:30 PM - Finding #RStats resources with Shiny and GitHub Actions
Nicola Rennie
One of the best parts of the R community is our love of sharing the things we learn, and many of us use social media to do just that! But in a world where social media can seem endless and somewhat unreliable, it felt like I needed a way to do two things: (i) bookmark links to interesting #RStats content that people share, and (ii) store that information somewhere that would remain accessible if my social media platform of choice ceased to exist. So I did what any R user would - I built a shiny app! Thanks to GitHub Actions, that Shiny app updates daily and displays the updated data in an interactive table. And it does it all while I'm asleep. In this talk I’ll discuss: - Collecting data from Twitter using {rtweet} - Scheduling tasks with GitHub Actions to update data - Triggering app re-deployment with GitHub Actions
3:30 - 4:00 PM - How to quickly build a production-ready Real-World-Data dashboard?
Kamil Wais
It's commonly known that R&Shiny can be used for quick prototyping, but what about quickly building complex production-ready dashboards? We will show that it’s also possible if only we initially invest some of our efforts into developing reusable production-ready dashboarding components. In our daily work, our team at Roche builds complex analytical dashboards for rapid Real-World-Data (RWD) exploration and hypothesis generation. Such dashboards need to work with different data sources and models, consist of different sets of integrated ready-to-use componentes, and have the ability to be customized with project-specific settings and modules. Because of those architectural drivers we propose and develop a modularized ecosystem of production-ready components, which are responsible for and very good at specific tasks, yet they are also properly abstracted so they can be easily reused in other projects and use cases. Some of the components that we’ve created are already open-sourced and we plan to open-source more of them in the future. In our talk we will show how one can build a production-ready dashboard using production-ready, well-tested components responsible for the following tasks: Generating rule-based artificial data for application development and testing. Creating complex cohorts using advanced filtering tools with clear separation of the interactive layer. Performing analysis on the selected cohort with an appropriate analytical module and visualizing the results. We will present those components, their features, benefits, and possible applications. What’s more we’ll show the effect of integrating those components in a single demo shiny app.
Third Day - Middle Segment
4:00 - 4:30 PM - DIY Pest Control: Effectively Debugging Shiny Apps
Tan Ho
At its best, Shiny is wonderful, elegant, and powerful. On the other hand, it can also reduce any of us to tears of frustration when we get stuck deep in the weeds of a complicated bug. As a new Shiny developer, it can be hard to figure out exactly where to start looking - especially if the app is not entirely your own!
4:30 - 5:00 PM - Turning our monolithic Shiny app into a microservices-based structure.
Juan Cruz Rodriguez, Ph.D.
Shiny is a popular framework for creating interactive web applications in R. However, as Shiny apps grow in complexity, it can become difficult to maintain and scale them. In this presentation, we will discuss how we turned our monolithic Shiny app into a microservices-based structure via backend API components.
By breaking our app into smaller, independent components, we were able to improve the maintainability and scalability of our application. We also gained the ability to easily create a public API for our app, which allowed us to avoid the need for copy and paste code through our applications.
Additionally, by moving to a microservices architecture, we no longer needed to have a Shiny daemon continuously running. This reduced the resource demands of our app and made it easier to deploy and manage.
Overall, our transition to a microservices-based structure has greatly improved the efficiency and flexibility of our Shiny app. We will share the challenges and benefits we encountered during the process, and provide practical tips for those looking to make a similar transition.
5:00 - 5:30 PM - New approach of visualisation with set of query in human readable way
Yuri Pribish
in such complicated systems which expect from end-user appropriate background and at least middle level of tech-savvy we’ve found that it’s a it harder to them interact with system in a quick way. The common problem is we show them all-in-one and give to users wide range of controls which could increase resistance ratio. The main Idea of this brand new approach is getting compact and useful component by gathering all needed controls such as filters, sorts, etc. in one module under particular use case.
5:00 - 5:30 PM - 1:1 Networking
We invite you to use this time for making new connections in one-on-one meetings.
In the networking segment, when you click the Ready button, the system automatically pairs you up with someone else who has also clicked the Ready button. This match is paired randomly. If both parties are available, the two are matched instantly and the video chat begins.You can also create 1:1 meetings with whoever you like. By going to the 'People' tab of the event, find the person you would like to connect with and click the invite to video call button.
5:30 - 6:30 PM - Say goodbye to unnecessary waiting: mastering asynchronous programming in Shiny
Veerle van Leemput
Are you tired of watching your Shiny app grind to a halt because of single, overloaded R session? And do you want to take your app to the next level? Then this keynote talk is for you! Join Veerle as she takes you on a journey through the world of asynchronous programming in Shiny. Let’s face it, nobody likes waiting around for an app to load. Today’s users expect almost instantaneous results and as a Shiny developer you need to make sure you meet those expectations. With asynchronous programming, you can keep your Shiny app running smoothly, even when your R session is busy with multiple tasks. Veerle will introduce you to powerful packages like future, promises, callR and coro that will help you break free from the constraints of a single R session where tasks are executed in the traditional and synchronous way. By the end of this keynote talk, you’ll be ready to start programming asynchronously and creating Shiny apps with improved efficiency, speed and user experience!
6:30 - 7:00 PM - The Shiny Apps I Didn’t Launch
Jacqueline Nolis
The greatest strength of Shiny is how it quickly it lets you go from an idea to a working prototype. Once you have a working interactive webpage, you can immediately understand what parts of your idea are sound and which don’t work in practice. But the downside of this is you may end up with many half completed Shiny apps that are interesting, but for engineering or product design reasons never got released.
This talk will cover several fascinating, bizarre, and peculiar Shiny apps* ideas I had, why I thought they were interesting but unlaunchable, and how the prototyping process in Shiny helped me along the way.
7:00- 7:30 PM - The Journey to a Successful Shiny Application Submission to FDA
Eric Nantz
Within the life sciences industry, Shiny has enabled tremendous innovations to produce web interfaces as frontends to sophisticated analyses, dynamic visualizations, and automation of clinical reporting across drug development. While industry sponsors have widely adopted Shiny as part of their analytics and reporting toolset, a relatively unexplored frontier has been the inclusion of a Shiny application inside a clinical submission package to regulatory agencies such as the FDA. After a successful pilot of an R-based clinical analysis submission package, the R Consortium R Submissions Working Group launched a second pilot in 2022 to test whether a Shiny application created with R could be assembled into a submission package and successfully transferred to FDA reviewers. In this talk, I will share the development journey of the Shiny application with key highlights of open-source collaboration, novel tooling in the Shiny ecosystem, challenges in the overall process, and the key milestones that led to a successful submission to the FDA. This project has the potential of becoming the first key reference of using Shiny in a regulatory context, paving the way for new innovations in how the life sciences industry can leverage R in new and innovative ways as part of clinical submissions.
7:30 - 8:00 PM - A Medical Educato(R)’s Journey to Data Science: Residency Applicants Ranking Dashboard and Algorithm – From Open Concept to Open Reality
Ken Koon Wong
How can we rank interview candidates more fairly? What form of data is needed to make that decision? How do we curate that data? How do we compile and summarize noisy data into something interpretable? How can we incorporate an algorithm that minimizes bias in recruitment? These questions are relevant for making an informed decision in recruiting candidates to be trained as future physicians. At the Cleveland Clinic Akron General Internal Medicine residency program, we have used the R Shiny dashboard for over three years to make recruitment more diverse, equitable, and inclusive. It would be very challenging for the human eyes to notice subtle differences in data for 100 to 200, or sometimes an even greater number of interview candidates, given 6 to 10 variables per candidate. We used multiple-criteria decision analysis (MCDA) as a potential solution to our question. The R Shiny dashboard is highly customizable, allows individualized program formula derivation with a chosen weight that matters most to the program’s core value, is easily accessible for program leadership to look at curated candidate assessment data, minimizes bias, and increases diversity in ranking, and provides another quantitative tool to tune PD’s intuition for ranking candidates. Most importantly, the R Shiny dashboard allowed the program leadership to visualize noisy data to enhance the ranking experience.
8:00 - 8:30 PM - Measuring performance improvement in Shiny apps
Douglas Mesquita
It is common to have performance issues in a Shiny application. Sometimes, it is due to a lack of knowledge on how to properly build the application, other times, it is because the application grew faster than expected and the structure is not the best anymore, or even technical debts were introduced during the development.
Performance issues can make users frustrated and as a result, the adoption can drop significantly. To avoid such a situation, developers are always trying to improve performance using several different techniques. However, we rarely know exactly what was the biggest source of improvement and how fast the application is compared to other versions. Also, most of the time, the performance is manually recorded which makes it difficult to reproduce the results or redo the analysis.
shiny.benchmark is a brand new Appsilon package that allows you to compare several different app’s versions in a very simple way. It can use two different engines to test the changes in the performance of your application: shinytest2 and Cypress. The main idea is to run a set of tests under different versions of an application (git refs). For each test and app version, shiny.benchmark will record the time elapsed to perform each task and return it for further analysis.
In this tutorial, I will teach you how to properly use shiny.benchmark through a simple example (document attached). Also, we will explore many functionalities of this package.
Third Day - Ending Segment
8:30 - 9:00 PM - Towards the next generation of Shiny UI
Carson Sievert
Shiny, the R package for creating interactive web graphics, recently celebrated its 10th birthday. Since then, Shiny has grown tremendously in many areas (e.g., performance, functionality, extensions, etc); however, a "hello world" Shiny app still looks like it did 10 years ago. This is mostly because Shiny goes to great lengths to ensure backwards compatibility; and as a result, default Shiny UI will likely continue to be based on Bootstrap 3 (a CSS styling framework released in 2010). However, thanks to the new bslib R package, it is now easy to opt-into a modern Bootstrap 5 foundation that "just works" with Shiny, R Markdown, flexdashboard, pkgdown, bookdown, and more.
In addition to upgrading Shiny's Bootstrap dependency, bslib also makes it much easier to do custom theming, leverage modern layout techniques, and create custom components (all from R without any CSS/HTML/JS required). At this point, bslib is still maturing, and does not yet provide what we'd consider a "complete UI toolkit", but it should eventually replace and/or improve upon all of Shiny UI. In this talk, I'll highlight bslib features that we're most excited about (e.g., expandable cards, accordions, (sidebar) layouts, input controls, etc.), discuss some best design practices for improving user experience with these tools, and present some real world examples of these tools in action.
9:00 - 10:00 PM - Lessons and opportunities with Shiny for Python
Winston Chang
For the past 10 years, the R community has been able to use Shiny to bring interactive data analyses to the web. Last summer, we announced that Shiny would also be available to for Python. In this talk, I’ll discuss what we’ve learned along the way, as well as the opportunities that Shiny for Python opens up. We are at the beginning of an exciting new era for Shiny, and I hope that community of old and new Shiny users make the most of it!
10:00 - 10:15 PM - Farewell from the Organizers & Program Committee
Marek Rogala, Joanna Mocko-Lazarewicz
All good things come to an end. Let's sum up ShinyConf 2023!
Marek Rogala, CTO at Appsilon and Program Committee Chair together with Joanna Mocko-Lazarewicz, Community Manager at Appsilon will share the closing remarks.
