Category: R

Introduction to Bayesian Multiple Imputation with the rblimp package workshop

Join our workshop on Introduction to Bayesian Multiple Imputation with the rblimp package,  which is a part of our workshops for Ukraine series! 


Here’s some more info: 


Title: Introduction to Bayesian Multiple Imputation with the rblimp package

Date: Thursday, July 23rd, 18:00 – 20:00 CEST (Rome, Berlin, Paris timezone) 

Speaker: Ermioni Athanasiadi is a PhD student at the University of Siegen, holding a master’s degree in psychology from University of Tübingen and currently pursuing a Master’s degree in Statistics and Data Science at Hasselt University, Belgium. Her research focuses on missing data methods in small-sample settings.  She is also passionate about interdisciplinary perspectives on statistics and research methodology.

Description:   Multiple Imputation has become the gold standard for handling missing data in applied research, with many researchers making use of the mice package. Blimp is an alternative, flexible software that allows multiple imputation within a fully Bayesian framework. In this workshop, we will cover the basics of multiple imputation and Blimp’s modeling framework. We will then explore how to specify imputation models, incorporate auxiliary variables, assess convergence and post-imputation diagnostics and conduct pooled analyses using multiply imputed datasets.

The workshop may be helpful both for those who are new to multiple imputation, and for those who have previously used multiple imputation methods and would like to learn about a Bayesian alternative.

Participants should install the Blimp software beforehand: https://www.appliedmissingdata.com/blimp

Minimal registration fee: 20 euro (or 20 USD or 800 UAH)


Please note that the registration confirmation is sent 1 day before the workshop to all registered participants rather than immediately after registration


How can I register?



  • Save your donation receipt (after the donation is processed, there is an option to enter your email address on the website to which the donation receipt is sent)

  • Fill in the registration form, attaching a screenshot of a donation receipt (please attach the screenshot of the donation receipt that was emailed to you rather than the page you see after donation).

If you are not personally interested in attending, you can also contribute by sponsoring a participation of a student, who will then be able to participate for free. If you choose to sponsor a student, all proceeds will also go directly to organisations working in Ukraine. You can either sponsor a particular student or you can leave it up to us so that we can allocate the sponsored place to students who have signed up for the waiting list.


How can I sponsor a student?


  • Save your donation receipt (after the donation is processed, there is an option to enter your email address on the website to which the donation receipt is sent)

  • Fill in the sponsorship form, attaching the screenshot of the donation receipt (please attach the screenshot of the donation receipt that was emailed to you rather than the page you see after the donation). You can indicate whether you want to sponsor a particular student or we can allocate this spot ourselves to the students from the waiting list. You can also indicate whether you prefer us to prioritize students from developing countries when assigning place(s) that you sponsored.


If you are a university student and cannot afford the registration fee, you can also sign up for the waiting list here. (Note that you are not guaranteed to participate by signing up for the waiting list).



You can also find more information about this workshop series,  a schedule of our future workshops as well as a list of our past workshops which you can get the recordings & materials here.


Looking forward to seeing you during the workshop!

2026 Rousseeuw Prize for Statistics Awarded to R Core Team for Transforming Statistics Computing Worldwide

The Rousseeuw Prize honors five pioneering developers for nearly three decades of unpaid work building R, the foundational open-source computing language behind artificial intelligence, healthcare, and economic decision-making.

  • The $1 million Rousseeuw Prize for Statistics recognizes three decades of foundational work that transformed how statistical methods are developed, validated, and shared globally.
  • R, the open-source statistical computing language, underpins modern AI development, pharmaceutical research, financial modeling, and global scientific analysis.
  • Used by organizations including the U.S. Food and Drug Administration, major pharmaceutical companies, and global central banks, R has become the trusted infrastructure for high-stakes analysis because it is stable, auditable, and reproducible.

NEW YORK – June 17, 2026 — Five members of the R Core Team have been awarded the prestigious Rousseeuw Prize for Statistics for their decades of work building and maintaining the R Project, “R,” a free and open-source statistical computing language used across global research institutions, healthcare systems, financial organizations, and technology companies. The Rousseeuw Prize is an international award recognizing major contributions to statistical research. 

The 2026 Rousseeuw Prize honorees are:

  • Brian D. Ripley, emeritus professor at the University of Oxford
  • Martin Maechler, emeritus professor at ETH Zurich
  • Kurt Hornik, department chair at WU Vienna University of Economics and Business
  • Peter Dalgaard, professor at Copenhagen Business School
  • Luke Tierney, professor at the University of Iowa

The five laureates receive half of the prize money because they are deemed to have made the longest sustained contributions to the R project; the other half of the prize is shared among the many others who have been active on the R Core Team.

Together, the R Project volunteers have spent the last 27 years and a collective 28,000 coding hours on R, developing an open-source programming language and software environment that transformed statistics from a proprietary corporate tool into a global public good. The software is relied upon by organizations including the U.S. Food and Drug Administration, pharmaceutical companies, and central banks such as the European Central Bank and the Bank of England.

The award recognizes the team’s role in making advanced statistical tools widely accessible. By keeping R free and open-source under the GNU General Public License, the R Core Team removed many of the financial barriers that have historically limited access to advanced analytics software. Due to this increased accessibility, hundreds of thousands of users including researchers, students, hospitals, public health organizations, and governments around the world are able to utilize the same statistical tools regardless of institutional resources. In addition, they use R to share transcripts of their data analyses, allowing one user’s workflows to power other users data analyses everywhere around the world. The frictionless spread of these transcripts has powered countless educational data science projects globally and hundreds of course textbooks at the PhD and Master’s level. In a recent twist, it’s not only humans who use R: AI data analyst `agents’ have been learning from the massive volume of published R transcripts and are now able to assist with many everyday data analysis tasks. 

“Long before AI became a global conversation, the R Core Team was building the statistical infrastructure that made today’s data-driven world possible,” said Stanford University statistics professor and leading statistician David Donoho, PhD. “This team’s stewardship of R created an open and trusted foundation for research across disciplines and continents. Few innovations have had such a profound effect on how knowledge is produced, shared, and validated in the modern era.”

Named after Professor Peter Rousseeuw, a pioneering Belgian statistician known for his foundational work in robust statistics and data analysis, the Rousseeuw Prize for Statistics recognizes innovations that have transformed the understanding and application of data for the benefit of society. Past laureates include internationally renowned statisticians and researchers whose work has advanced fields ranging from epidemiology and artificial intelligence to public policy and scientific discovery.

For more information, visit https://www.rousseeuwprize.org/.

###

Media Contact:

[email protected]

{talib}: Interactive financial charts

{talib} is a new R package built on TA-Lib, which is now available on CRAN. The R-package is targeted at individuals and, perhaps, institutions who, in some form or the other, interacts with the financial markets using technical analysis.

The library is built with minimal dependencies for long-term stability and freedom in mind. All functions are built around data.frame– and matrix-classes which are portable to all other data-containers with minimal effort.

Everything in the library is built ‘bottom-up’ for maximum speed and memory efficiency. Each indicator interacts directly with R’s C API via .Call().

In this blog post I will give a brief introduction to the charting interface which is built to mimick the behaviour of base R’s plotting API.

A quick introduction to charts

In this section I will briefly introduce the most important aspects of the charting, ‘quality of life’-features and themes. Below is a simple starting point; charting BTC:

talib::chart(
  talib::BTC
)

chart() returns a candlestick chart by default. Below are the formals:

str(formals(talib::chart))
#> Dotted pair list of 5
#>  $ x    : symbol 
#>  $ type : chr "candlestick"
#>  $ idx  : NULL
#>  $ title: symbol 
#>  $ ...  : symbol

Modifying themes

talib::set_theme("hawks_and_doves")

talib::chart(
  talib::BTC
)

Charting indicators

{
  talib::chart(talib::BTC)
  talib::indicator(talib::SMA, n = 7)
  talib::indicator(talib::SMA, n = 14)
  talib::indicator(talib::SMA, n = 21)
  talib::indicator(talib::SMA, n = 28)
  talib::indicator(talib::MACD)
  talib::indicator(talib::trading_volume)
}

Installation

{talib} is finally on CRAN, and can be installed as follows:

install.packages("talib")

It can also be built from source with additional CMake-flags:

install.packages(
  "talib",
  type = "source",
  configure.args = "-O3 -march=native"
)

Contributing and submitting bug-reports

{talib} is still in its early stage so contributions, even if small, bug-reports, suggestions and critiques are gratefully accepted.

Visit the repository here: https://github.com/serkor1/ta-lib-R.

Created on 2026-04-29 with reprex v2.1.1

Announcing shiny.webawesome: a web UI package for R/Shiny

shiny.webawesome brings Web Awesome to R Shiny through generated wrappers, reactive bindings, and a bundled runtime. It aims for complete component support while staying close enough to upstream that the Web Awesome docs and examples are directly useful in everyday package use.

CRAN | R-universe | Package website | Source repository

Background

shiny.webawesome started from a perceived gap: Shiny would benefit from a UI library that feels modern, visually polished, and broad enough to support a full app coherently. Web Awesome was a strong fit because it combines rich components, layout and styling utilities, and detailed upstream documentation with a standards-based web-components structure that is straightforward to track from R. That makes it easier for the package to stay close to upstream while still fitting naturally into Shiny.

The Whole Game

Here’s a screenshot of a simple, complete example app using shiny.webawesome. The full live app and code are available in an article at: https://mbanand.github.io/ghpages/announcement/..

Screenshot of a shiny.webawesome example app showing a control sidebar and coordinated chart, summary, and details views.

This example showcases many of the facilities available in the package:

  • a visually rich component library
  • direct use of Web Awesome layout utilities such as wa-stack, wa-cluster, wa-gap-*, and wa-align-* classes
  • styling through Web Awesome design tokens and classes such as --wa-color-*, --wa-font-*, and wa-body-*
  • reactive Shiny input bindings
  • helpers for calling methods on HTML elements, setting properties, and injecting simple JavaScript snippets

Design Philosophy

shiny.webawesome is designed to stay close to upstream Web Awesome. Most component wrappers are generated from Web Awesome metadata, which helps preserve upstream names, structure, and behavior while translating the interface into normal R conventions such as snake_case.

That close alignment has a practical benefit: when you want deeper details, examples, or component-specific guidance, you can usually go straight to the upstream Web Awesome documentation and apply what you find directly in shiny.webawesome. The package currently supports all Web Awesome components, so the upstream docs are a practical reference for day-to-day use.

To support the server-client model of Shiny, the package adds a small set of page and layout helpers, curated reactive bindings, and a narrow command layer for cases where browser-side interaction goes beyond the generated wrappers.

The result is a package with a clear default path. Use generated wrappers for ordinary UI, use bindings for meaningful reactive state, and reach for commands or small JavaScript glue when the app needs them.

Shiny Bindings

shiny.webawesome does not forward every browser event and every detail of component telemetry into Shiny. Much component state and interaction detail is better handled locally in the browser rather than turned into server messages. Consequently, the package exposes only a curated set of Shiny bindings that fit Shiny’s reactive model, with an emphasis on meaningful committed state rather than low-level browser event streams.

In the most common case, a binding publishes a durable semantic value. A select reports its current value, a dialog can report whether it is open, and a tree can report the currently selected item ids. The key idea is that Shiny receives the state the app actually cares about, not the raw event name that happened to produce it.

Some components are better treated as actions than values. A button is the clearest example: in Shiny, it behaves like a Shiny action input, with each click producing a new input event. A small number of components need both action semantics and a separate value. A dropdown, for example, may need to trigger reactivity on every choice, including repeated selections of the same item, while also exposing the latest selected value.

This design keeps reactive messaging to the server smaller, clearer, and easier to reason about. If an interaction belongs naturally in Shiny’s input model, shiny.webawesome will expose it as a binding. If it is more naturally a browser-side concern, it is usually a better fit for the command layer or a small amount of JavaScript glue.

For the full binding categories, semantics, and examples, see the package article: Shiny Bindings.

Command API

shiny.webawesome covers the most common interaction patterns through generated wrappers, Shiny bindings, and update helpers. But sometimes an app still needs to reach into a live browser element directly: set a property, call a method, or add a small browser-local JavaScript snippet.

For those cases, the package provides a narrow command API. The two main server-side helpers are wa_set_property() and wa_call_method(). They let Shiny code send one-way commands to a browser element identified by id, either by assigning a value to a live property or invoking a browser-side method.

If a component already has a binding or update helper, that should usually remain the first choice. The command layer is for the cases that fall just outside those built-in paths, where the simplest solution is still to tell the existing browser component to do one specific thing.

The package also includes wa_js() for a different kind of job: small, app-local JavaScript glue. That is useful when the missing piece is browser-side logic such as listening for an event, reading live component state, or publishing a derived value back to Shiny with Shiny.setInputValue().

For more detail and examples, see the package article: Command API.

Conclusion

shiny.webawesome brings a visually rich component library into Shiny while staying close to upstream Web Awesome. That combination gives polished components, useful layout and styling utilities, and a workflow where upstream documentation and examples remain directly relevant throughout app development.

For more examples, longer articles, and full reference material, see the package website: shiny-webawesome.org.

RStudio AI That Doesn’t Cost a Penny: llmcoder vs. Posit AI Assistant

Introduction

If you’re an R user, you’ve probably experienced these moments:

  • You’re writing code and forgot the exact syntax for a function
  • Your code throws an error and you’re staring at a confusing error message
  • You have a block of code but want to understand what it does in plain English
  • You want to chat with an AI assistant about your data analysis, but don’t want to leave RStudio

llmcoder is an RStudio addin that solves all of these problems by integrating Large Language Model (LLM) assistance directly into your RStudio workflow, and more importantly, it’s FREE!

In this post, I’ll show you how llmcoder can speed up your R coding and make your workflow smoother.

Watch a quick demo of llmcoder in action:

https://youtu.be/SRzjaURbKCw

Installation

You can install llmcoder from GitHub:

# Install remotes if you haven't already
install.packages("remotes")

# Install llmcoder
remotes::install_github("ShiyangZheng/llmcoder")

Load the package:

library(llmcoder)

Feature 1: Generate R Code from Inline Comments

Ever wish you could just type what you want in plain English and get R code instantly?

How to use:

  1. Type a comment describing what you want
  2. Place your cursor on that line
  3. Use the Addins menu and select “Generate Code from Comment”

Example:

# Load the mtcars dataset and create a scatter plot of mpg vs wt, colored by number of cylinders

After running the addin, the comment is replaced with:

library(ggplot2)
data(mtcars)
ggplot(mtcars, aes(x = wt, y = mpg, color = factor(cyl))) +
  geom_point(size = 3, alpha = 0.8) +
  labs(
    title = "Fuel Efficiency vs Weight by Cylinder Count",
    x = "Weight (1000 lbs)",
    y = "Miles per Gallon",
    color = "Cylinders"
  ) +
  theme_minimal()

No more switching to ChatGPT or copying code from Stack Overflow!

Feature 2: Fix Console Errors with LLM Assistance

We’ve all been there – a cryptic error message and you’re not sure what went wrong.

How to use:

  1. Run code that produces an error
  2. The error appears in the console
  3. Use the Addins menu and select “Fix Error with LLM”

Example:

library(dplyr)
data %>%
  filter(cyl == 4) %>%
  summary()
# Error: object 'data' not found

llmcoder captures the error and sends it to the LLM, which returns an explanation and suggests:

mtcars %>% filter(cyl == 4) %>% summary()

Feature 3: Explain Selected Code in Plain English

Sometimes you inherit code from a colleague or find a Stack Overflow answer and want to understand what it does.

How to use:

  1. Select a block of code in the editor
  2. Use the Addins menu and select “Explain Code”

Example:

mtcars %>%
  group_by(cyl) %>%
  summarize(
    mean_mpg = mean(mpg, na.rm = TRUE),
    sd_mpg = sd(mpg, na.rm = TRUE),
    count = n()
  ) %>%
  arrange(desc(mean_mpg))

llmcoder returns:

  1. Takes the built-in mtcars dataset
  2. Groups the data by the number of cylinders (cyl)
  3. Calculates the mean and standard deviation of miles per gallon (mpg) for each group
  4. Arranges the results in descending order of mean fuel efficiency

Feature 4: Multi-Turn Chat Panel with Session Context

This is the flagship feature. llmcoder includes a Chat Panel that understands your current R session.

How to open: Use the Addins menu and select “Open Chat Panel”

What makes it special?

The Chat Panel is session-aware:

  • It knows which packages you have loaded
  • It knows what objects are in your global environment
  • It can read the contents of your current script
  • It has access to your recent console history

Example conversation:

You: What’s the correlation between mpg and wt in mtcars?

AI: The correlation between mpg and wt in the mtcars dataset is -0.87, indicating a strong negative relationship. As weight increases, fuel efficiency decreases.

cor(mtcars$mpg, mtcars$wt, use = "complete.obs")

Want to see the Chat Panel in action? Watch this demo:
https://youtu.be/zP-RuCN3q14

Supported LLM Providers

llmcoder supports multiple LLM providers – you can choose the one that works best for you:

Provider API Key Notes
OpenAI (GPT-4/3.5) Yes Most popular
Anthropic (Claude) Yes Great for long conversations
DeepSeek Yes Cost-effective
Groq Yes Very fast inference
Together AI Yes Open-source models
OpenRouter Yes Access multiple models
Ollama No Fully local, no API key!
Custom endpoint Yes LM Studio, vLLM, llama.cpp

Privacy note: If you use Ollama, all processing happens locally on your machine. No data is sent to external servers.

Customization: Choose Your Prompt Style

The Chat Panel allows you to select different prompt styles:

  • General Assistant: Best for general questions
  • R Code Helper: Focuses on writing clean, idiomatic R code
  • Statistics Advisor: Helps with statistical concepts and test selection
  • Research (Psycho): Tailored for psycholinguistics researchers

Why llmcoder?

There are many AI coding assistants out there (Copilot, Cursor, etc.), so why llmcoder?

  1. Native RStudio integration: No need to switch to another app or browser tab
  2. Session-aware: The LLM knows what you’re working on
  3. Multiple LLM providers: Choose the one you prefer (or use a local model for privacy)
  4. Open source: MIT license, free to use and modify
  5. Designed for R users: Not a generic coding assistant – it understands R-specific workflows

Call to Action

Ready to try llmcoder?

remotes::install_github("ShiyangZheng/llmcoder")

GitHub: https://github.com/ShiyangZheng/llmcoder

If you encounter any bugs or have feature requests, please file an issue: https://github.com/ShiyangZheng/llmcoder/issues

Star the repo if you find it useful!

About the Author

Shiyang Zheng is a PhD student in Psycholinguistics at the University of Nottingham. His research focuses on idiom acquisition and computational modeling. He built llmcoder to make R coding easier for himself and the R community.

DIVINE: a new R package for working with a real-world COVID-19 clinical cohort


Clinical data are rarely as clean, compact or convenient as the examples we often use when teaching statistics or R. Real hospital datasets are usually distributed across several tables, include missing values, contain repeated structures, and require careful documentation before they can be reused.

The new R package DIVINE is interesting precisely because it brings that reality into the R ecosystem in an accessible way.  Available on CRAN, DIVINE provides a curated collection of datasets from a multicentre cohort of hospitalized COVID-19 patients in the south metropolitan area of Barcelona. The package is accompanied by a recent publication in Scientific Data, which describes the database, its structure, data collection process and potential reuse for clinical epidemiology, teaching and methodological research.

A clinical dataset packaged for R

The package includes 14 datasets covering different clinical domains, such as demographics, comorbidities, symptoms, vital signs, severity scores, ICU information, treatments, complications, vaccination and end-of-follow-up data.

This relational structure is one of the most valuable aspects of the package. Instead of providing a single pre-merged analysis file, DIVINE preserves the logic of a real clinical database, where information is distributed across several linked tables. This makes it especially useful for applied teaching and for demonstrating realistic data-management workflows in R.

For example:

install.packages("DIVINE")
library(DIVINE)

data(package = "DIVINE")

The datasets can then be loaded in the usual way:

data("demographic")
data("vital_signs")
data("scores")

The common identifiers allow users to combine information across tables and build analysis datasets depending on the research question.

More than a data package

Although the datasets are the main contribution, DIVINE also includes helper functions for common epidemiological data workflows. These include:

data_overview()
multi_join()
stats_table()
multi_plot()
impute_missing()
export_data()

These functions are not intended to replace the broader R ecosystem, but they make the package easier to use in teaching, exploratory analysis and reproducible examples.

A minimal workflow might look like this:

library(DIVINE)

data("demographic")
data("vital_signs")
data("scores")

baseline <- multi_join(
  list(demographic, vital_signs, scores),
  key = c("record_id", "covid_wave", "center"),
  join_type = "left"
)

data_overview(baseline)

stats_table(
  baseline,
  vars = c("age", "sex"),
  by = "covid_wave",
  statistic_type = "median_iqr",
  pvalue = TRUE
)

This example already illustrates several important aspects of clinical data analysis: understanding table structure, joining related datasets, checking variables, and producing descriptive summaries.

Why it is useful for R users

For a specialised R audience, the value of DIVINE is not only that it provides COVID-19 data. Its main interest is that it offers a realistic, documented and reusable clinical database within a familiar R workflow.

The package may be useful for:

  • teaching data management with relational clinical datasets;

  • preparing examples for biostatistics or epidemiology courses;

  • demonstrating descriptive clinical analyses;

  • exploring missing data and variable availability;

  • developing prognostic modelling examples;

  • validating prediction models;

  • creating reproducible workflows using real-world health data.

This makes DIVINE particularly attractive for applied biostatisticians, epidemiologists, clinical researchers and R instructors who want to move beyond toy datasets.

Regression Modeling Strategies Short Course 2026, with Frank Harrell; May 14, 15, 18, 19

Frank Harrell’s Regression Modeling Strategies online seminar will take place May 14, 15, 18, and 19.

This workshop covers principled strategies for building, validating, and interpreting multivariable regression models for a wide range of outcomes, with emphasis on predictive accuracy, avoiding overfitting, and interpreting estimated effects. It explores spline methods, data reduction, benefits of Bayesian modeling, robust semiparametric ordinal, longitudinal, and survival models, and rigorous resampling-based validation, illustrated with applied case studies and R examples. More details here.

Along with the 1-day Introduction to R, Regression, and the rms Package, these virtual seminars are offered through Instats, in association with the A.S.A.

Reactive Shiny Apps and Deployment with Google Cloud Run: Intermediate R Shiny Workshop

Join our workshop on Reactive Shiny Apps and Deployment with Google Cloud Run: Intermediate R Shiny Workshop,  which is a part of our workshops for Ukraine series! 


Here’s some more info: 


Title: Reactive Shiny Apps and Deployment with Google Cloud Run: Intermediate R Shiny Workshop 

Date: Thursday, May 21st, 18:00 – 20:00 CET (Rome, Berlin, Paris timezone) 

Speaker:Alfredo Hernández Sánchez is a Marie Skłodowska Curie ERA Postdoctoral Fellow at Vilnius University, where he leads the FIRSA project on financial regulation and innovation in Europe. His work combines applied research, data analysis, and reproducible computational methods, with a strong interest in turning research outputs into accessible digital tools such as dashboards and interactive web applications. He works extensively with R, Quarto, and Shiny in academic and policy-oriented settings.

www.alfredohs.com 

Description:  This workshop is designed for people who already know the basics of Shiny and want to build apps that are more robust, more reactive, and easier to maintain. We will look at practical reactive patterns, app structure, and some common choices that make Shiny dashboards easier to develop as they become more complex. In the second part of the workshop, I will show how a Shiny app can move from local development to a public deployment on Google Cloud Run, using a real dashboard project as an example. The session will give participants a practical introduction to a cloud-based workflow for publishing and maintaining Shiny applications in highly customizable environment. Basic familiarity with Shiny is assumed, and some previous experience building simple apps will help participants get the most out of the session.

Minimal registration fee: 20 euro (or 20 USD or 800 UAH)







Please note that the registration confirmation is sent 1 day before the workshop to all registered participants rather than immediately after registration


How can I register?



  • Save your donation receipt (after the donation is processed, there is an option to enter your email address on the website to which the donation receipt is sent)

  • Fill in the registration form, attaching a screenshot of a donation receipt (please attach the screenshot of the donation receipt that was emailed to you rather than the page you see after donation).

If you are not personally interested in attending, you can also contribute by sponsoring a participation of a student, who will then be able to participate for free. If you choose to sponsor a student, all proceeds will also go directly to organisations working in Ukraine. You can either sponsor a particular student or you can leave it up to us so that we can allocate the sponsored place to students who have signed up for the waiting list.


How can I sponsor a student?


  • Save your donation receipt (after the donation is processed, there is an option to enter your email address on the website to which the donation receipt is sent)

  • Fill in the sponsorship form, attaching the screenshot of the donation receipt (please attach the screenshot of the donation receipt that was emailed to you rather than the page you see after the donation). You can indicate whether you want to sponsor a particular student or we can allocate this spot ourselves to the students from the waiting list. You can also indicate whether you prefer us to prioritize students from developing countries when assigning place(s) that you sponsored.


If you are a university student and cannot afford the registration fee, you can also sign up for the waiting list here. (Note that you are not guaranteed to participate by signing up for the waiting list).



You can also find more information about this workshop series,  a schedule of our future workshops as well as a list of our past workshops which you can get the recordings & materials here.


Looking forward to seeing you during the workshop!










 














CougarStats: a free and open-source Statistics web app for Teaching and Learning

Hello,

I’d like to share CougarStats, a free and open-source R Shiny web app I developed to support the teaching and learning of Statistics. CougarStats runs entirely in a browser and is designed for accessibility and ease of use. You can explore the app here: https://www.cougarstats.ca/ 
 
The name CougarStats is inspired by Mount Royal University’s athletics mascot, the cougar, symbolizing strength and agility, and by the app’s focus on statistics. 
 
Key features of CougarStats
 
  • Descriptive Statistics: Compute measures like mean, median, mode, quartiles, IQR, standard deviation, and identify potential outliers. 
  • Data Visualization: Construct Boxplots, Histograms, and Scatterplots. 
  • Probability: Calculate marginal, joint, union, and conditional probability for contingency tables; exact and cumulative probabilities for Binomial, Poisson, Negative Binomial and Hypergeometric distributions; and cumulative probabilities for the Normal distribution. 
  • Sample Size Estimation: Determine the required sample sizes for various scenarios. 
  • Statistical Inference: Construct confidence intervals, conduct hypothesis tests for one- and two-samples (mean, proportion and standard deviation). 
  • ANOVA: Perform one-way Analysis of Variance with an option to conduct Bonferroni post hoc tests. 
  • Regression and Correlation: Fit simple linear regression models and compute Pearson correlation coefficient, multiple linear regression, logistic regression. 
  • Categorical Data Analysis: Perform Chi-Square test of independence with and without Yates’ continuity correction, Fisher’s exact test. 
  • Nonparametric Tests: Perform the Mann-Whitney U Test, Kruskal-Wallis test etc.
 
I would be delighted if you could explore CougarStats and share it with your students and colleagues who might find it useful.
 
Thank you for your time, and I look forward to hearing your thoughts.
 
Sincerely, 
Ashok

—
Ashok Krishnamurthy, PhD
Associate Professor
Department of Mathematics and Computing
Mount Royal University
4825 Mount Royal Gate SW
Calgary, AB, T3E 6K6 Canada