Discover how to use the new Positron Assistant AI agent to automatically generate R code that produces interactive world maps on your own dataset.

In this tutorial, you will learn how to:

• Use LLM prompts on your own data to generate R code with the Positron Assistant and the ellmer R package

• Prepare and join your dataset with world geodata using rnaturalearth and countrycode

• Design interactive choropleth world maps with the leaflet package

• Add informative labels, detailed popups, and a polished legend to your maps

We will carefully review the R code generated by the LLM prompt, so you can easily adapt the code for your own use cases.

Check out the video now:

Setting Up Claude Sonnet 4

First, let’s see how to set up the ellmer package to chat with a large language model (LLM), in this case, Claude Sonnet 4. It’s also good practice to manage your API keys securely using your .Renviron file.

library(ellmer)

# get the API key: https://console.anthropic.com/settings/admin-keys
# add ANTHROPIC_API_KEY=xxx in .Renviron using usethis::edit_r_environ()
chat <- chat_anthropic(
  api_key = Sys.getenv("ANTHROPIC_API_KEY"),
  model = "claude-sonnet-4-20250514",
  params = params(temperature = 0) # reduce randomness
)

Here, we’re first loading the ellmer package which is our interface to the LLM. We create a chat object using our API key (securely stored in .Renviron). Setting temperature = 0 helps make the code generated by the LLM as reproducible as possible—this minimizes randomness.

Generating R Code to Fetch Country GDP Data

Now, we want the LLM to generate R code that fetches country-level GDP data for 2023 using the wbstats R package. The prompt is designed to return only the code, without code block syntax.

prompt_get_data <- "Get country gdp for 2023 using wbstats R package. Return only code without backsticks."

code_generated <- chat$chat(prompt_get_data)

chat$get_cost() # show costs

[1] $0.00

Here, we’ve put our prompt as a string and passed it to our chat object to generate the R code. We can also call get_cost() to check how much this interaction costs—it’s pretty cheap as less than $0.00.

Fetching and Cleaning Data

Let’s now use the generated code to fetch the GDP data and prepare it for mapping. Here, we use the wbstats package to get GDP values, and the dplyr package to clean and organize our dataset to two essential columns: country name and GDP.

library(wbstats)

gdp_2023 <- wb_data(
  indicator = "NY.GDP.MKTP.CD",
  start_date = 2023,
  end_date = 2023
)

print(gdp_2023)

# A tibble: 217 × 9
   iso2c iso3c country             date NY.GDP.MKTP.CD unit  obs_status footnote
   <chr> <chr> <chr>              <dbl>          <dbl> <chr> <chr>      <chr>   
 1 AW    ABW   Aruba               2023    3648573136. <NA>  <NA>       <NA>    
 2 AF    AFG   Afghanistan         2023   17152234637. <NA>  <NA>       <NA>    
 3 AO    AGO   Angola              2023   84875162197. <NA>  <NA>       <NA>    
 4 AL    ALB   Albania             2023   23547180412. <NA>  <NA>       <NA>    
 5 AD    AND   Andorra             2023    3785067332. <NA>  <NA>       <NA>    
 6 AE    ARE   United Arab Emira…  2023  514130432648. <NA>  <NA>       <NA>    
 7 AR    ARG   Argentina           2023  646075277525. <NA>  <NA>       <NA>    
 8 AM    ARM   Armenia             2023   24085749592. <NA>  <NA>       <NA>    
 9 AS    ASM   American Samoa      2023            NA  <NA>  <NA>       <NA>    
10 AG    ATG   Antigua and Barbu…  2023    2005785185. <NA>  <NA>       <NA>    
# ℹ 207 more rows
# ℹ 1 more variable: last_updated <date>

library(dplyr)

gdp_2023_cleaned <- gdp_2023 |>
  rename(GDP = NY.GDP.MKTP.CD) |>
  select(country, GDP)

We use wb_data() to download the data: each row represents a country and its 2023 GDP. The rename and select steps ensure our data has a simple and clean structure: just country and GDP, making it ready for merging with geographic data.

Loading a System Prompt Template

The next step is to use a prompt template. In Positron, you can specify reusable markdown prompt templates (with .prompt.md extension) that provide detailed instructions to the LLM.

By reading and collapsing the prompt template, we have a reproducible way to instruct the LLM exactly how we want our world map code to be generated—encapsulating prompt engineering in one place.

Let’s load our prompt template into R now.

👇👇👇 Full prompt below 👇👇👇

# path_prompt <- ".github/prompts/create-world-map_leaflet-giscoR-countrycode.prompt.md"

# prompt_system <- readLines(path_prompt) |>
#   paste0(collapse = "\n") # clean text

prompt_system <- "
You are an expert R programmer specializing in interactive geospatial visualizations and data mapping.

Your task is to create an interactive choropleth world map using the leaflet R package, incorporating user-provided data with world geodata from rnaturalearth package.

First, check if the user has provided a dataset. If no dataset is provided, only ask briefly the user to include a dataset.

Follow these steps:

1. Load necessary R packages (leaflet, rnaturalearth, rnaturalearthdata, countrycode, dplyr, and any other required packages)

2. Use the dataset provided by the user and examine its structure

3. Get world geodata using the rnaturalearth package (ne_countries function). Then use dplyr::filter on this geodata to keep only the variable names "name", "iso_a3" and "geometry"

4. Use the countrycode package to standardize country codes to ISO3 format for proper joining between the user dataset and geodata

5. Join the user dataset with the world geodata (using "iso_a3" column) using appropriate dplyr functions

6. Create color palette and binning for the choropleth visualization using leaflet's colorBin or colorNumeric functions. Adjust the color palette with the distribution of the user dataset.

7. Build the interactive map using leaflet package with:
   - Professional base tiles (consider CartoDB.Positron or similar clean options)
   - Choropleth polygons with appropriate fill colors and styling
   - Clean, informative labels for each country
   - Detailed popup information showing relevant data from the user's dataset
   - Professional legend with clear formatting
   - Appropriate zoom levels and center positioning

8. Apply professional styling including border colors, opacity settings, and hover effects

9. Ensure the map is responsive and visually appealing with proper color schemes

Always give minimal solution and avoid unnecessary additions. Return only R code without backticks such as ```r ```. Prefer using tidyverse packages and style guide.
"

str(prompt_system) # prompt in string

chat$set_system_prompt(prompt_system)

Resetting the LLM User Chat History

When using the ellmer package, it’s good practice to clear previous chat history to avoid unwanted context carryover between different prompts. This step resets the user message history, but keeps our system prompt active in the background.

chat$set_turns(list()) # clean user chat

Generating R Code with Context About Our Data

Now, we want the LLM to generate the map code in the context of our cleaned GDP dataset. Here, we provide not only the dataset but also a summary of its structure (using the btw package, short for “by the way”) to help the LLM generate more relevant and accurate code.

library(btw) # pak::pak("posit-dev/btw")

code_generated <- chat$chat(
  btw::btw(gdp_2023_cleaned) # add data description in the LLM context
)

chat$get_turns(include_system_prompt = FALSE)

chat$get_cost() # show costs

By using the btw() function from the btw package, we give the LLM a short summary of our dataset, which improves the quality of its output. We also check the cost of this prompt.

Saving the Generated Code

Sometimes, you might want to copy the LLM-generated code for quick re-use or review. The clipr package lets you send this code directly to your clipboard.

library(clipr)

clipr::write_clip(code_generated)

Loading Packages for Mapping

Now it’s time to prepare for the map creation. We load several packages that will help us draw the interactive world choropleth map, join geospatial data to our GDP data, and deal with country code mismatches.

library(leaflet)
library(giscoR)
library(countrycode)
library(dplyr)

These packages play key roles: leaflet for mapping, giscoR for geodata, countrycode for harmonizing country names, and dplyr for data manipulation.

Downloading World Geodata

Let’s get the geospatial data for world countries using giscoR. This function retrieves country polygons as sf-style geometries, which are compatible with leaflet.

world <- gisco_get_countries(resolution = "60", epsg = "4326")

Harmonizing Country Identifiers

To safely join our GDP data to the world geodata—especially given possible variations in country name formats—we use ISO3 codes as a common identifier. The countrycode package helps us convert country names to ISO3 codes.

gdp_2023_cleaned <- gdp_2023_cleaned %>%
  mutate(ISO3_CODE = countrycode(country, "country.name", "iso3c"))

Warning: There was 1 warning in `mutate()`.
ℹ In argument: `ISO3_CODE = countrycode(country, "country.name", "iso3c")`.
Caused by warning:
! Some values were not matched unambiguously: Channel Islands, Kosovo

This step creates a new column, ISO3_CODE, in our GDP dataset for safe merging based on standardized codes.

Merging GDP Data with Geodata

Now, we join the GDP data to the world polygons, ensuring every country polygon has its associated GDP value.

world_data <- world %>%
  left_join(gdp_2023_cleaned, by = "ISO3_CODE")

Now our world_data object contains geometries (for the map) and data (for color scaling and popups).

Creating Color Palette for Choropleth Mapping

GDP values span several orders of magnitude, so we want to use logarithmic bins for the map’s color palette. This ensures the visual differences are meaningful across high and low GDP countries.

bins <- c(0, 1e10, 5e10, 1e11, 5e11, 1e12, 5e12, 1e13, 5e13)
pal <- colorBin(
  "Blues",
  domain = world_data$GDP,
  bins = bins,
  na.color = "#808080"
)

We define custom bins and use a blue color palette for our map, making it intuitive and visually appealing while handling missing data gracefully.

Creating Informative Labels for Popups

Next, let’s create the contents for our pop-up labels. Here, we display the country name and its GDP (formatted in billions, with proper rounding and separators). Missing values are handled clearly.

labels <- sprintf(
  "<strong>%s</strong><br/>GDP: $%s billion",
  world_data$NAME_ENGL,
  ifelse(
    is.na(world_data$GDP),
    "No data",
    format(round(world_data$GDP / 1e9, 1), big.mark = ",")
  )
) %>%
  lapply(htmltools::HTML)

We use sprintf() for rich HTML formatting and wrap the result with htmltools::HTML so that leaflet will interpret it correctly.

Building the Interactive Leaflet Map

Now, we want to bring everything together and construct the actual interactive map using the leaflet package. The map uses dark base tiles, overlays colored polygons by GDP, and provides interactive popups and a legend.

leaflet(world_data) %>%
  addProviderTiles(providers$CartoDB.DarkMatter) %>%
  addPolygons(
    fillColor = ~ pal(GDP),
    weight = 0.5,
    opacity = 1,
    color = "white",
    dashArray = "3",
    fillOpacity = 0.7,
    highlightOptions = highlightOptions(
      weight = 2,
      color = "#666",
      dashArray = "",
      fillOpacity = 0.8,
      bringToFront = TRUE
    ),
    label = labels,
    labelOptions = labelOptions(
      style = list("font-weight" = "normal", padding = "3px 8px"),
      textsize = "13px",
      direction = "auto"
    )
  ) %>%
  addLegend(
    pal = pal,
    values = ~GDP,
    opacity = 0.7,
    title = "GDP (USD)",
    position = "bottomright",
    labFormat = labelFormat(
      prefix = "$",
      suffix = "B",
      transform = function(x) round(x / 1e9, 1)
    )
  ) %>%
  setView(lng = 0, lat = 20, zoom = 2)

This chunk creates the interactive world map. Each country is colored by its GDP, with a color gradient applied according to the custom bins. The map includes interactive popups for each country and a customized legend that displays GDP in billions of US dollars.

Conclusion

We’ve demonstrated how to automate the generation of world map code using LLM-powered tools directly from R, preparing real datasets and joining them with geospatial data, and customizing your interactive leaflet map for your own use cases. This approach gives you full programmatic control, reproducibility, and the opportunity to adapt AI-generated code exactly how you want it.

Thank you for following this tutorial—experiment and customize further to make your own interactive world maps!

See you in another tutorial, bye bye!

I just published a new YouTube tutorial showing how to create and fully customize beautiful values boxes using the bslib and bs4Dash R packages. I also show how to include customized interactive graphics in the value boxes using the plotly R package.

In the video you will learn how to:

• Explore value boxes parameters using the “Build a Box” demo app.

• Customize bslib value boxes with the bslib R package.

• Integrate customize interactive graphics in your value boxes.

• Use values boxes in your shiny apps.

• Create and customize value boxes using the bs4Dash R package.

Watch the video now:

Getting Started with the bslib demo app

Let’s get started directly with this bslib “Build a box” demo application which you can access at: https://bslib.shinyapps.io/build-a-box/

As you can see in the value box settings, you can change the inputs and whatever you write for example numbers and the value box will automatically update. When it’s done, you can click on show code and you can simply download the code.

Key Features You Can Customize:

Title and Value: You can change the title, the value, you can easily add extra text in the markdown also if you want. And as you can see it will be showed in the value box.

Theme Colors: You can change the theme. This is bootstrap color. So primary color is blue. But if you go on success for example, it will be green because this is a default color for success in bootstrap. If you want to use your own custom colors, you can do it also by clicking on this changing the URL of the colors and you will get the colors that you want.

Full Screen Mode: You can also allow full screen. This is quite a nice features of the cards of bslib which is using the background of the value box function. You can click on this button to click on expand and you get extra information about the x-axis which you don’t see in a smaller value box. So this is pretty nice.

Showcase Options: Also, the third section is related to the showcase. You can have a very simple value box like this. But if you want to add an interactive plot or an icon, you can do it very easily. So you can first choose where to put this showcase:

• At the bottom

• As the left center (which is default)

• At the top right

Let’s put it back in the left center for example. You decided to have a plot. We can have a line, a bar, or possibly a box. We will see how you can also fully customize this interactive graphics a bit later on. You can also change the colors. You can fully customize them if you want.

You can also instead of a plot use an icon and you have the list of different icons you can use and you can choose the one you want.

Required R Packages

First, let’s load the necessary libraries/R packages we will use:

library(bslib)
library(plotly)
library(htmltools)
library(bsicons)
library(shiny)
library(bs4Dash)
library(htmlwidgets)

Creating Value Boxes with bslib

Let’s copy paste the example code that we just created using the demo app. If we run this line of code, you will see in the viewer the cards appearing:

layout_columns(
  value_box(
    title = "Package Numbers", value = "409,446", shiny::markdown("asdfsd"),
    theme = "primary", showcase = "Your Plot", showcase_layout = "left center",
    full_screen = TRUE, fill = TRUE, height = NULL
  ),
  value_box(
    title = "AWS Cloud Spending", value = "$3,463", , theme = "success",
    showcase = "Your Plot", showcase_layout = "left center",
    full_screen = TRUE, fill = TRUE, height = NULL
  ),
  value_box(
    title = "Project Stars", value = "5,100", , theme = NULL,
    showcase = bsicons::bs_icon("star"), showcase_layout = "left center",
    full_screen = FALSE, fill = TRUE, height = NULL
  )
)

Key Function: layout_columns is a bslib function to create the layout by column as the function says.

Understanding the Parameters:

You can simply call the value box function with:

• Title — the main heading • Value — the key metric or number

• Extra content — markdown or HTML code to fully customize the content

• Theme — color scheme (primary, success, etc.)

• Showcase — where we put the code for plots or icons

• Full screen — set to TRUE to enable expansion, FALSE to disable

• Fill and height — layout customization options

We can change the theme from primary (blue) to success (green). The showcase is where we will have to put the code for the plot, and if you want the full screen, you put it true. If you want to remove it false. We want to fill and you can also customize the height of your card.

Creating Interactive Graphics (Spark Lines)

As mentioned previously, we want to create the interactive graphics now. The documentation is at: https://rstudio.github.io/bslib/articles/value-boxes/

As you can see on the official bslib package documentation regarding value boxes, you have all the information to create the value boxes including using shiny and this layout column to wrap it differently using bslib.

If you go to expandable spark lines, which are actually the name for this mini interactive plots, you have the code to create this spark line object which is called in the showcase to create this.

Actually, what I did is simply copy paste the code, and this is the code. Let’s go quickly through it so you know also how you can customize your interactive spark line:

sparkline <- plot_ly(economics) %>%
  add_lines(
    x = ~date, y = ~psavert,
    color = I("white"), span = I(1),
    fill = 'tozeroy', alpha = 0.2
  ) %>%
  layout(
    xaxis = list(visible = F, showgrid = F, title = ""),
    yaxis = list(visible = F, showgrid = F, title = ""),
    hovermode = "x",
    margin = list(t = 0, r = 0, l = 0, b = 0),
    font = list(color = "white"),
    paper_bgcolor = "transparent",
    plot_bgcolor = "transparent"
  ) %>%
  config(displayModeBar = FALSE) %>%
  htmlwidgets::onRender(
    "function(el) {
      el.closest('.bslib-value-box')
        .addEventListener('bslib.card', function(ev) {
          Plotly.relayout(el, {'xaxis.visible': ev.detail.fullScreen});
        })
    }"
  )

Understanding the Spark Line Code:

Data Source: This is using plotly with the economics data set which is automatically loaded when you load the plotly package.

Color Customization: If you run this first chunk of code, you will see in the viewer your plotly code, but you don’t see the line because we specify we wanted it white. But if you want to have it in a different color and you run again this chunk of code, as you can see now it’s in blue.

Layout Cleanup: We also want to remove the grid and some information about the axis. So we use a layout argument. Now you don’t see anything because everything is either transparent or white. But this is what we want. We want also to remove this mode bar so you can call it the display mode bar inside the config function as false and this mode bar will disappear.

Quarto Integration: Finally, and this is only specifically if you want to use spark line in your Quarto document reports, you can use this on render function with this javascript code. As explained in the documentation page, this JavaScript is actually equivalent to say show the x-axis on the chart when it’s taller than 200 pixels, otherwise hide it. There was a little bug when you display it with this x-axis and this is the code to fix this. We will see also how to do the equivalent with shiny.

Creating a Complete Value Box with Spark Line:

We will run this chunk of code to have our spark line object and we will again use value box with a different example with customized code to put extra lines if it’s useful for you:

value_box(
  title = "Personal Savings Rate",
  value = "7.6%",
  p("Started at 12.6%"),
  p("Averaged 8.6% over that period"),
  p("Peaked 17.3% in May 1975"),
  showcase = sparkline,
  showcase_layout = "bottom",
  full_screen = TRUE,
  theme = "success"
)

As you can see in the showcase we have our spark line object we just created and we have it at the bottom.

Creating Value Boxes with Shiny

Let’s see how to do it also with shiny. I’ll take again an example from the official documentation of bslib:

ui <- page_fluid(
  theme = bslib::bs_theme(
    base_font = font_google("Atkinson Hyperlegible")
  ),
  br(),
  layout_column_wrap(
    width = "200px",
    class = "mt-3",
    value_box(
      title = "Unemployment Rate",
      value = "2.7%",
      p("Started at 1.5%"),
      p("Averaging 3%"),
      p("Peaked at 5.2% in Dec 1982"),
      showcase = plotlyOutput("unemploy"),
      full_screen = TRUE
    ),
    value_box(
      title = "Personal Savings Rate",
      value = "7.6%",
      p("Started at 12.6%"),
      p("Averaging 8.6%"),
      p("Peaked at 17.3% in May 1975"),
      showcase = plotlyOutput("psavert"),
      showcase_layout = showcase_top_right(),
      full_screen = TRUE,
      theme = "success"
    ),
    value_box(
      title = "Personal Consumption",
      value = "$3.8B",
      p("Started at $0.25B"),
      p("Averaging $1.7B"),
      showcase = bsicons::bs_icon("piggy-bank", size = "100%"),
      full_screen = TRUE,
      theme = "danger"
    )
  )
)

UI Structure

We will create a page fluid which is a function from bslib. You can customize it and as again this layout column wrap with some classes and the width and we will add the three value boxes as examples.

Important: As you can see in the showcase line, instead of calling our spark line object, we will call plotlyOutput with an id which is actually calling the spark line object in the server side.

Server Logic

This is the server code from the documentation:

server <- function(input, output) {
  output$unemploy <- renderPlotly({
    plotly_time_series(
      economics,
      x = ~date,
      y = ~ 100 * unemploy / pop
    )
  })
  
  output$psavert <- renderPlotly({
    plotly_time_series(
      economics,
      x = ~date,
      y = ~psavert
    )
  })
  
  output$pce <- renderPlotly({
    plotly_time_series(
      economics,
      x = ~date,
      y = ~ 100 * pce / pop
    )
  })
  
  plotly_time_series <- function(d, x, y) {
    info <- getCurrentOutputInfo()
    large <- isTRUE(info$height() > 200)
    
    plot_ly(d, x = x, y = y) %>%
      add_lines(
        color = I(info$fg()),
        span = I(1),
        #hoverinfo = if (!large) "none",
        fill = 'tozeroy',
        alpha = 0.2
      ) %>%
      layout(
        hovermode = "x",
        margin = list(t = 0, r = 0, l = 0, b = 0),
        font = list(color = info$fg()),
        paper_bgcolor = "transparent",
        plot_bgcolor = "transparent",
        xaxis = list(
          title = "",
          visible = large,
          showgrid = FALSE
        ),
        yaxis = list(
          title = "",
          visible = large,
          showgrid = FALSE
        )
      ) %>%
      config(displayModeBar = FALSE)
  }
}

shinyApp(ui, server)

Again for each spark line we have a different render plotly calling the plotly time series function which is actually a function created which creates a plotly object.

Let’s run this chunk of code so you have an idea about what it does. This is the shiny application running. And as expected we have our interactive spark lines with the different information we wanted. And the beauty of shiny is like every time the data updates in the server, new value boxes would be updated accordingly.

Creating Value Boxes with bs4Dash

Right now I want to show you also how to create value boxes. This time with the bs4Dash R package.

bs4Dash has different functions to build your packages. It starts with a dashboard page function and then you can call the functions for the different argument to build the header, the sidebar, control bar, footer, the title and the body:

ui <- dashboardPage(
  header = dashboardHeader(),
  sidebar = dashboardSidebar(),
  controlbar = dashboardControlbar(),
  footer = dashboardFooter(),
  title = "test",
  body = dashboardBody(
    fluidRow(
      valueBoxOutput("vbox")
    )
  )
)

server = function(input, output) {
  output$vbox <- renderValueBox({
    valueBox(
      value = 150,
      subtitle = "New orders",
      color = "primary",
      icon = icon("shopping-cart"),
      href = "#"
    )
  })
}

shinyApp(ui, server)

This is an example taken once again from the official documentation from BS4Dash package. And as you can see we will create this time the value box in the server side. This is pretty similar to bslib. You can choose:

• Value — the main metric

• Subtitle — descriptive text

• Color — theme color

• Icon — visual element

• Href — optional link

And this value box is simply rendered in the UI.

Let’s run this chunk of code and we will see how it looks like with BS4Dash. This is the value box with BS4Dash with the different parameters as we customized them.

Adding Spark Lines to bs4Dash Value Boxes

Now we want to add a spark line also which we customize just as we did with bslib. Let’s see how to do that now.

Once again I will reuse the code from the official documentation:

Enhanced bs4Dash UI with Spark Lines

ui <- dashboardPage(
  header = dashboardHeader(),
  sidebar = dashboardSidebar(),
  controlbar = dashboardControlbar(),
  footer = dashboardFooter(),
  title = "bs4Dash value boxes",
  body = bs4DashBody(
    fluidRow(
      valueBox(
        value = 150,
        subtitle = "New orders",
        color = "primary",
        icon = icon("cart-shopping")
      ),
      valueBox(
        value = "53%",
        subtitle = "New orders",
        color = "indigo",
        icon = icon("gears"),
        footer = plotlyOutput("salesSparkline", height = "50px"),
        width = 4,
        elevation = 4
      ),
      valueBox(
        value = "44",
        subtitle = "User Registrations",
        color = "teal",
        icon = icon("sliders")
      )
    )
  )
)

As you can see it’s pretty similar, but this time we use the value box function directly in the UI. And for the second value box we will use this time the footer argument to create your interactive spark line once again using plotly output.

Customized Server Logic

If we go on the server side, this time I customized a bit the economics data set with some data wrangling to make it look better:

server <- function(input, output) {
  
  output$salesSparkline <- renderPlotly({
    
    econ_data <- economics %>%
      tail(24) %>%  # Using last 24 months for visualization
      mutate(
        month_name = format(date, "%b %Y"),
        unemployment_millions = unemploy / 1000  # Convert to millions for cleaner display
      )
    
    plot_ly(
      data = econ_data, 
      x = ~date, 
      y = ~unemployment_millions, 
      type = "scatter", mode = "lines",
      line = list(color = "#ffffff", width = 2),
      text = ~paste("Date:", month_name, 
                    "<br>Unemployment:", round(unemployment_millions, 2), "M",
                    sep = ""),
      hoverinfo = "text") %>%
      layout(
        paper_bgcolor = "rgba(0,0,0,0)",
        plot_bgcolor = "rgba(0,0,0,0)",
        margin = list(l = 0, r = 0, b = 0, t = 0, pad = 0),
        xaxis = list(
          showgrid = FALSE, 
          zeroline = FALSE, 
          showticklabels = FALSE,
          title = ""  # Removed x-axis title
        ),
        yaxis = list(
          showgrid = FALSE, 
          zeroline = FALSE, 
          showticklabels = FALSE,
          title = ""  # Removed y-axis title
        ),
        showlegend = FALSE,
        hovermode = "closest"
      ) %>%
      config(displayModeBar = FALSE)
  })
}

shinyApp(ui, server)

And you can again fully customize your plot object. And you have the two arguments to customize the tool tip. And you can change this code as you want.

And once it’s done, you can simply run the UI, the server and once again shiny apps. And as we wanted, we have our value box with this interactive spark lines with a nice tooltip.

Conclusion

Value boxes are a powerful way to display key metrics and information in your R applications. Whether you’re using bslib for modern, customizable cards or bs4Dash for dashboard-style layouts, both packages offer extensive customization options.

Key Takeaways from This Tutorial:

• Use the BSLib demo app to quickly prototype your value boxes

• Integrate interactive spark lines using plotly for enhanced data visualization

• Leverage the full-screen capability for detailed views

• Choose between bslib and bs4Dash based on your application’s design requirements

Happy coding with R! 🚀

In this video you will learn how to:

• create reports using Quarto in RStudio.

• add specific parameters / variables to fully customize your reports.

• use an R script to produce all your reports automatically.

Watch the video now:

Why Automated Reports Are So Useful

Posit, the company who developed and maintains Quarto, just released a new article showing how to use parameters in Quarto to automate Word documents, PowerPoints, PDFs, and HTML pages very easily for full automation.

We’ll go through this article showing you how easy it is now to have specific parameters like years, months, weeks for example for the timeline, or by name, by companies, by regions - whatever you need.

Concrete Example

Here is a concrete example: if you want to create reports for different years, you can choose a year parameters and you can create different Word documents or PDFs based on this unique variable.

As Quarto supports either R or Python, we will concentrate on R programming.

Setting Up Your First Parametric Report

Let’s open RStudio now. In RStudio, you just go to File > New File or click on the new file button and simply click on “Quarto Document”. This will open a window with a title that will be the title of your document, the author (Felix Analytix), and you can choose HTML, PDF, or Word format. Let’s go for Word here.

Here’s our basic Quarto template with parameters:

---
title: "How to Fully Automate Reports using R programming"
author: "Felix Analytix"
format: docx
params:
  name: "Luke Skywalker"
  year: "2024"
---

Hello `{r} params$name`!

## Sub section for `{r} params$year`

Hello !

library(dplyr)

starwars |> 
  dplyr::filter(name == params$name)

Let’s break down what’s happening here:

1. We add two parameters in our YAML header: name and year

2. We use the starwars dataset from the dplyr package, which contains information about Star Wars characters

3. We can reference parameters inline using params$name or params$year

4. We filter our dataset to show only information for the specified character

When you click “Render”, you’ll get a Word document that says “Hello Luke Skywalker!” and shows the filtered dataset containing only Luke Skywalker’s information.

You can change the parameter values to get different reports for each Star Wars character. For example, changing the name to “C-3PO” will create a report specifically for that character.

Full Automation: Creating Multiple Reports

Now for the most exciting part - full automation! Our goal is to create different reports for each character name with a specific greeting and filtered dataset.

For this, we need to create another R script that will generate all reports automatically:

library(dplyr)
library(purrr)

data <- expand.grid(
  name = unique(starwars$name),
  year = "2024",
  stringsAsFactors = FALSE)

df <- data |> 
  dplyr::mutate(
    output_format = "docx",       # Output format (html, word, etc.)
    output_file = paste(          # Output file name
      name, year, "report.docx",
      sep = "_"
    ),
    execute_params = purrr::map2( # Named list of parameters
      year, name, 
      \(year, name) list(name = name, year = year)
    )
  ) |> 
  dplyr::select(-c(name, year))

df

purrr::pwalk(
  .l = df,                      # Dataframe to map over
  .f = quarto::quarto_render,   # Quarto render function
  input = "20240823-automate-report.qmd",       # Named arguments of .f
  .progress = TRUE              # Optionally, show a progress bar
)

Here’s what this automation script does:

1. Create parameter combinations: We use expand.grid() to create all combinations of names and years

2. Build output specifications: We specify the output format (docx) and create unique filenames for each report

3. Set up parameters: We create a list of parameters for each report using purrr::map2()

4. Generate all reports: We use purrr::pwalk() with quarto::quarto_render() to create all reports automatically

When you run this code, you’ll see in the R console that it’s building reports for each Star Wars character. This process takes around 10 minutes depending on your system and the number of reports being generated.

Key Benefits

This automated approach offers several advantages:

• Scalability: Generate hundreds or thousands of reports with minimal effort

• Consistency: All reports follow the same template and formatting

• Efficiency: Once set up, the entire process runs automatically

• Flexibility: Easy to modify parameters and add new variables

While this was already possible with R Markdown, Quarto makes it even more streamlined and integrates better with other programming languages.

Conclusion

I hope this tutorial was useful! I wanted to share this amazing new feature of Quarto that makes report automation incredibly straightforward. Whether you’re creating reports for different time periods, clients, regions, or any other parameter, this approach can save you countless hours of manual work.

The combination of Quarto’s parametric reports with R’s data manipulation capabilities provides a powerful framework for automated reporting that scales beautifully with your needs.

Would you like to know how to create multiple pages dashboards using R Shiny?

In this tutorial you will learn how to:

• create multiple pages using the bs4Dash R package;

• build a fully customized sidebar with a logo and different categories of texts;

• add a footer in your R Shiny dashboards;

• change the theme and colors using Bootstrap 4;

• and more…

Watch the video now:

In this tutorial, you’ll learn how to create a dashboard with multiple tabs that function as different pages. While Shiny applications are technically single-page applications, we can create the illusion of multiple pages using tabs and navigation elements.

Required Packages

To create a dashboard with multiple pages, you’ll need to install the shiny package (if you haven’t already) and the bs4Dash package developed by David Granjon. Let’s start by installing and loading these packages:

# Install R packages if not installed

if (!require(shiny)) install.packages("shiny")
if (!require(bs4Dash)) install.packages("bs4Dash")

Creating an Empty Skeleton

Let’s begin with an empty skeleton to understand the basic structure of a bs4Dash application:

# Empty skeleton

library(shiny)
library(bs4Dash)

ui <- dashboardPage(
  title = "Basic Dashboard",
  header = dashboardHeader(),
  sidebar = dashboardSidebar(),
  controlbar = dashboardControlbar(),
  footer = dashboardFooter(),
  body = dashboardBody()
)

server <- function(input, output) {}

shinyApp(ui = ui, server = server)

This creates a basic dashboard with an empty sidebar. If you’re not familiar with Shiny’s structure (UI, server, and the interaction between them), I recommend checking out my previous videos in this series.

Understanding the Dashboard Structure

The dashboardPage() function is the main container for your bs4Dash application. It accepts several arguments:

• header: The top navigation bar

• sidebar: The left navigation panel

• controlbar: An optional right sidebar

• footer: The bottom section

• body: The main content area

For this tutorial, we’ll focus primarily on the user interface (UI) since our server function remains empty - we’re concentrating on layout and navigation rather than reactive functionality.

Building a Complete Dashboard

Now let’s create a full example with multiple pages. Here’s the complete code that demonstrates all the key concepts:

# Full example

ui <- dashboardPage(
  title = "Basic Dashboard",
  header = dashboardHeader(
    title = dashboardBrand(
      title = "bs4Dash",
      color = "primary",
      href = "https://felixanalytix.com",
      image = "https://felixanalytix.com/about/image-profile.jpg",
    ),
    skin = "light",
    status = "white"
  ),
  sidebar = dashboardSidebar(
    skin = "light",
    status = "primary",
    elevation = 3,
    sidebarUserPanel(
      image = NULL,
      name = "Welcome Onboard!"
    ),
    sidebarMenu(
      sidebarHeader("Header 1"),
      menuItem(
        "Item 1",
        tabName = "item1",
        icon = icon("sliders")
      ),
      menuItem(
        "Item 2",
        tabName = "item2",
        icon = icon("chart-simple")
      )
    )
  ),
  footer = dashboardFooter(
    left = p("Download the R code: ", a(
      href = "https://felixanalytix.com",
      target = "_blank", "felixanalytix.com"
    ))
  ),
  body = dashboardBody(
    tabItems(
      tabItem(
        tabName = "item1",
        fluidRow(
          lapply(1:3, FUN = function(i) {
            sortable(
              width = 4,
              p(class = "text-center", paste("Column", i)),
              lapply(1:2, FUN = function(j) {
                box(
                  title = paste0("I am the ", j, "-th card of the ", i, "-th column"),
                  width = 12,
                  "Click on my header"
                )
              })
            )
          })
        )
      ),
      tabItem(
        tabName = "item2",
        box(
          title = "Card with charts",
          width = 9
        )
      )
    )
  )
)

server <- function(input, output) {}

shinyApp(ui = ui, server = server)

Key Components Explained

Header Configuration

The dashboardHeader() creates the top navigation bar. Key features include:

• title: Uses dashboardBrand() to create a clickable logo/title

• color: “primary” gives it a blue color (Bootstrap default)

• href: Makes the title clickable and directs to your website

• skin: “light” provides a light theme (you can also use “dark”)

Sidebar Navigation

The dashboardSidebar() contains your navigation menu:

• status: Controls the color scheme (primary = blue)

• sidebarUserPanel(): Adds a welcome message or user info

• sidebarMenu(): Contains the navigation items

Creating Multiple Pages

The key to creating multiple pages lies in the connection between menuItem() in the sidebar and tabItem() in the body:

1. menuItem(): Each menu item needs a unique tabName

2. tabItem(): Each tab content must have a matching tabName

This correspondence is crucial - the tabName in your menuItem() must exactly match the tabName in your tabItem().

Bootstrap Integration

The bs4Dash package leverages Bootstrap CSS framework, which provides:

• Predefined color schemes (primary, secondary, warning, danger, info)

• Consistent styling across components

• Easy theme customization

Instead of hard-coding colors, you can use Bootstrap’s semantic color names, making it easy to change your entire app’s color scheme by modifying just the theme.

HTML Structure in R

You might notice that functions are nested within other functions throughout the code. This mimics HTML’s tree-like structure where elements are nested within parent elements. This is necessary because our R code is ultimately generating HTML, CSS, and JavaScript for the web browser.

Adding Content to Your Pages

Each tabItem() can contain any Shiny UI elements:

• boxes: For organizing content

• fluidRow(): For responsive layouts

• Charts, tables, inputs: Any interactive elements

Conclusion

You now have the foundation for creating multi-page dashboards using bs4Dash. This approach gives you a sidebar-based navigation system, which is different from traditional Shiny applications that typically use tabs at the top of the page.

The key takeaways are:

1. Use dashboardPage() as your main container

2. Create navigation with menuItem() in the sidebar

3. Match tabName between menu items and tab content

4. Leverage Bootstrap colors for consistent theming

5. Understand that nested functions mirror HTML structure

In future tutorials, we’ll explore how to customize these cards and add interactive functionality to make your dashboards even more powerful.

Today you will learn how to:

• create a simple R Shiny User Interface (UI) Layout;

• how to add a sidebar with inputs;

• add multiple rows, columns, tabs and pages in R Shiny;

• add a theme and fully customize colors and fonts;

• and more…

Watch the video:

Load R packages

Before we begin, make sure you have the required packages installed:

install.packages(c("shiny", "tidyverse", "gt", "bslib"))

Single Page Layout with Sidebar

Let’s start with the most common Shiny layout pattern - a sidebar layout. This creates a clean interface with controls on the left and main content on the right.

library(shiny)
library(tidyverse)
library(gt)

ui <- fluidPage(
  titlePanel("Starwars Dashboard"),
  sidebarLayout(
    sidebarPanel(
      selectInput(
        inputId = "character", 
        label = "Choose a Character:", 
        choices = unique(starwars$name),
        selected = unique(starwars$name)[1],
        multiple = TRUE
      )
    ),
    mainPanel(
      gt::gt_output("characterInfos")
    )
  )
)

server <- function(input, output) {
  output$characterInfos <- gt::render_gt({
    dplyr::starwars %>% 
      filter(name %in% input$character) %>%
      gt() %>%
      opt_interactive()
  })
}

shinyApp(ui = ui, server = server)

This layout demonstrates the fundamental structure of a Shiny application:

• sidebarPanel: Contains input controls (in this case, a character selector)

• mainPanel: Displays the main content (an interactive table)

• Reactive filtering: The table updates automatically based on user selection

The sidebar layout is responsive and automatically adapts to different screen sizes, making it mobile-friendly.

Multi-Row Layouts with Grid System

For more complex interfaces, you’ll need precise control over element positioning. Shiny uses Bootstrap’s 12-column grid system, allowing you to create custom layouts with multiple rows and columns.

ui <- fluidPage(
  titlePanel("Starwars Dashboard"),
  fluidRow(
    column(6, plotOutput("plot1")),
    column(6, plotOutput("plot2"))
  ),
  fluidRow(
    column(12, gt::gt_output("table"))
  )
)

server <- function(input, output) {
  output$plot1 <- renderPlot({ 
    starwars %>%
      count(hair_color, gender) %>%
      ggplot(aes(hair_color, n, fill = gender)) + 
      geom_col()
    })
  output$plot2 <- renderPlot({ 
    starwars %>%
      count(eye_color, gender) %>%
      ggplot(aes(eye_color, n, fill = gender)) + 
      geom_col()
    })
  output$table <- gt::render_gt({ starwars })
}

shinyApp(ui = ui, server = server)

Key concepts:

• fluidRow(): Creates horizontal rows

• column(width, ...): Defines column width (1-12) and content

• Bootstrap grid: Total width of 12 columns per row

• Responsive design: Automatically stacks columns on smaller screens

In this example: - First row: Two plots side by side (6 columns each) - Second row: One full-width table (12 columns)

Tabbed Interfaces

Tabs are perfect for organizing related content without overwhelming users. They provide a clean way to separate different views or analyses.

ui <- fluidPage(
  titlePanel("Starwars Dashboard"),
  tabsetPanel(
    tabPanel("Plot", plotOutput("plot")),
    tabPanel("Summary", verbatimTextOutput("summary")),
    tabPanel("Data", gt::gt_output("table"))
  )
)

server <- function(input, output) {
  output$table <- gt::render_gt({ starwars })
  output$summary <- renderPrint({ summary(starwars$height) })
  output$plot <- renderPlot({ ggplot(starwars, aes(x = height, fill = gender)) + 
      geom_density(alpha = 0.5) })
}

shinyApp(ui = ui, server = server)

Tab components: - tabsetPanel(): Container for all tabs - tabPanel(title, content): Individual tab with title and content - Content flexibility: Each tab can contain any Shiny output

You can also combine tabs with the grid system by adding fluidRow() and column() within tab panels for even more layout control.

Multi-Page Applications with Navigation

For larger applications, you might need multiple pages. The navbarPage() function creates a professional navigation bar at the top of your application.

ui <- navbarPage(
  title = "Starwars Dashboard",
  tabPanel("Introduction", p("An app for analyzing Starwars data.")),
  tabPanel("Data", gt::gt_output("dataTable")),
  navbarMenu("More Analyses",
             tabPanel("Height Analysis", plotOutput("heightPlot")),
             tabPanel("Mass Analysis", plotOutput("massPlot"))
  )
)

server <- function(input, output) {
  output$dataTable <- gt::render_gt({ gt(starwars) |> opt_interactive() })
  output$heightPlot <- renderPlot({ ggplot(starwars, aes(height)) + geom_histogram() })
  output$massPlot <- renderPlot({ ggplot(starwars, aes(mass)) + geom_histogram() })
}

shinyApp(ui = ui, server = server)

Navigation features: - navbarPage(): Creates the main navigation structure - tabPanel(): Individual pages in the navigation - navbarMenu(): Dropdown menus for grouping related pages - Professional appearance: Clean, modern navigation bar

Theming with Bootstrap

The bslib package provides easy access to pre-built Bootstrap themes, allowing you to quickly change your application’s appearance.

library(bslib)

ui <- navbarPage(
  title = "Starwars Dashboard",
  theme = bslib::bs_theme(bootswatch = "cerulean"), # BOOTSWATCH THEME
  tabPanel("Introduction", p("An app for analyzing Starwars data.")),
  tabPanel("Data", gt::gt_output("dataTable")),
  navbarMenu("More Analyses",
             tabPanel("Height Analysis", plotOutput("heightPlot")),
             tabPanel("Mass Analysis", plotOutput("massPlot"))
  )
)

server <- function(input, output) {
  output$dataTable <- gt::render_gt({ gt(starwars) |> opt_interactive() })
  output$heightPlot <- renderPlot({ ggplot(starwars, aes(height)) + geom_histogram() })
  output$massPlot <- renderPlot({ ggplot(starwars, aes(mass)) + geom_histogram() })
}

shinyApp(ui = ui, server = server)

Popular Bootswatch themes include: - cerulean (shown above) - flatly - darkly - cosmo - journal - lumen

Custom Color Schemes

For complete control over your application’s appearance, you can define custom colors and styling with bslib.

library(bslib)

ui <- fluidPage(
  theme = bslib::bs_theme(bg = "#E8E8E8", fg = "#242424", primary = "#D4B836"),
  titlePanel("Starwars Dashboard"),
  sidebarLayout(
    sidebarPanel(
      sliderInput("massInput", "Select Maximum Mass:",
                  min = min(starwars$mass, na.rm = TRUE),
                  max = max(starwars$mass, na.rm = TRUE),
                  value = 40)
    ),
    mainPanel(
      plotOutput("massPlot")
    )
  )
)

server <- function(input, output) {
  output$massPlot <- renderPlot({
    starwars %>%
      filter(mass <= input$massInput) %>%
      ggplot(aes(x = name, y = mass)) +
      geom_col()
  })
}

shinyApp(ui = ui, server = server)

Custom theme parameters: - bg: Background color - fg: Foreground (text) color
- primary: Primary accent color for buttons, links, etc. - Additional options: secondary, success, info, warning, danger

Conclusion

You now have the tools to create sophisticated Shiny layouts! Here’s what we covered:

1. Basic sidebar layouts for simple interfaces

2. Grid system with rows and columns for precise control

3. Tabbed interfaces to organize content

4. Multi-page navigation for complex applications

5. Theme customization for professional styling

See you in another tutorial!

In this first episode you will learn how to:

• access a gallery of hundreds of examples of R Shiny applications;

• fully understand all the R code behind a basic R Shiny app;

• get the intuition of how input-output interactions work in a Shiny app;

• add a new text input in a Shiny app.

Check out the video now:

Starting with a Simple Single Layout

Let’s begin with the most basic Shiny layout structure. Here’s our first example:

# This is a Shiny web application. You can run the application by clicking
# the 'Run App' button above.
#
# Find out more about building applications with Shiny here:
#
#    https://shiny.posit.co/
#

library(shiny)

# Define UI for application that draws a histogram
ui <- fluidPage(

    # Application title
    titlePanel("Old Faithful Geyser Data"),

    # Sidebar with a slider input for number of bins 
    sidebarLayout(
        sidebarPanel(
            sliderInput("bins",
                        "Number of bins:",
                        min = 1,
                        max = 50,
                        value = 30)
        ),

        # Show a plot of the generated distribution
        mainPanel(
           plotOutput("distPlot")
        )
    )
)

# Define server logic required to draw a histogram
server <- function(input, output) {

    output$distPlot <- renderPlot({
        # generate bins based on input$bins from ui.R
        x    <- faithful[, 2]
        bins <- seq(min(x), max(x), length.out = input$bins + 1)

        # draw the histogram with the specified number of bins
        hist(x, breaks = bins, col = 'darkgray', border = 'white',
             xlab = 'Waiting time to next eruption (in mins)',
             main = 'Histogram of waiting times')
    })
}

# Run the application 
shinyApp(ui = ui, server = server)

This code demonstrates the fundamental structure of a Shiny application. The library(shiny) command loads the Shiny package, which is essential for creating web applications. The ui object defines the user interface using fluidPage(), which creates a responsive layout that automatically adjusts to different screen sizes.

The titlePanel() function creates the application header, while sidebarLayout() establishes the classic two-column structure with a sidebar on the left and main panel on the right. Inside sidebarPanel(), we use sliderInput() to create an interactive slider that allows users to select the number of bins for the histogram. The mainPanel() contains plotOutput(), which displays the histogram generated by the server logic.

The server function contains the reactive logic. The renderPlot() function creates the histogram dynamically based on the user’s input from the slider. It accesses the faithful dataset (built into R), extracts the waiting times, creates bins based on the slider value, and generates the histogram with custom styling.

Adding More Interactive Elements

Now let’s enhance our application by adding more interactive elements to see how the layout adapts:

library(shiny)

# Define UI for application that draws a histogram
ui <- fluidPage(

    # Application title
    titlePanel("Old Faithful Geyser Data"),

    # Sidebar with a slider input for number of bins 
    sidebarLayout(
        sidebarPanel(
            sliderInput("bins",
                        "Number of bins:",
                        min = 1,
                        max = 50,
                        value = 30),
            textInput("text",
                      label = h3("what is your name?"),
                      value = "Felix")
        ),

        # Show a plot of the generated distribution
        mainPanel(
           plotOutput("distPlot"),
           verbatimTextOutput("valueText")
        )
    )
)

# Define server logic required to draw a histogram
server <- function(input, output) {

    output$valueText <- renderText({ input$text })
    
    output$distPlot <- renderPlot({
        # generate bins based on input$bins from ui.R
        x    <- faithful[, 2]
        bins <- seq(min(x), max(x), length.out = input$bins + 1)

        # draw the histogram with the specified number of bins
        hist(x, breaks = bins, col = 'darkgray', border = 'white',
             xlab = 'Waiting time to next eruption (in mins)',
             main = 'Histogram of waiting times')
    })
}

# Run the application 
shinyApp(ui = ui, server = server)

In this enhanced version, we’ve expanded both the sidebar and main panel with additional elements. The textInput() function creates a text input field where users can enter their name. The h3() function creates an HTML heading for the input label, making it more prominent than regular text.

In the main panel, we’ve added verbatimTextOutput() alongside the existing plot. This creates a text output area that displays exactly what the user types in the text input field. The renderText() function in the server creates a reactive text output that automatically updates whenever the user changes the input.

This demonstrates how the sidebarLayout() can accommodate multiple elements in both panels while maintaining the clean, organized structure. The layout automatically handles the spacing and arrangement of these elements.

See you in another tutorial!

In my new YouTube video, I show you how to use RStudio Projects and Git version control to follow a consistant file structure and track all the changes in your code.

You will learn how to:

• use RStudio projects and connect them to Git and GitHub (the easy way);

• use RStudio Git panel view to commit, push and pull files with 1 click;

• see an example of a data science project file structure.

Watch the video now:

Data science projects can quickly become chaotic without proper organization and version control. In this tutorial, you’ll learn how to use RStudio Projects and Git to maintain clean, organized, and portable data science workflows.

The Problem: Disorganized Project Folders

Many data scientists end up with folders that look like this:

• analysis.R

• new-analysis.R

• new-analysis-version2.R

• ideas-from-document.R

• Mixed files from different projects in the same directory

This disorganized approach leads to confusion, lost work, and difficulty collaborating with others. Let’s fix this using RStudio Projects and Git version control.

Creating Your First RStudio Project

Step 1: Start a New Project

1. Click on the New Project button in the top-right corner of RStudio

2. You’ll see three options:

   • New Directory: Creates a new folder

   • Existing Directory: Uses an existing folder

   • Version Control: Connects to Git (we’ll cover this later)

Step 2: Choose Project Type

Select New Directory, then choose from various project templates: - Empty new project (recommended for beginners) - R package - Shiny application - Quarto projects - And other specialized templates

Step 3: Configure Your Project

1. Directory name: This becomes your project folder name (e.g., “organized”)

2. Subdirectory: Choose where to save your project

   • Pro tip: Create a dedicated folder for all your data science projects

   • Consider syncing with cloud storage (OneDrive, Google Drive, etc.)

3. Optional settings:

   • Git repository (we’ll set this up separately)

   • renv for package management (recommended for advanced users)

Click Create Project to finish setup.

Understanding Project Benefits

Automatic Working Directory

RStudio Projects automatically set your working directory to the project root. This means:

# Instead of complex file paths like this:
read_csv("/Users/username/long/path/to/project/data/data.csv")

# You can use simple relative paths:
read_csv("data/data.csv")

This makes your projects portable – you can move the entire folder anywhere and the code still works.

Project File Structure

The .Rproj file in your project folder tells RStudio this is an RStudio Project. Benefits include:

• Easy project switching via the top-right dropdown menu

• Automatic working directory management

• Project-specific settings and history

• Better organization across multiple projects

Recommended Folder Structure

For consistency across projects, follow R package conventions:

your-project/
├── data/           # Raw and processed data
├── R/              # R scripts and functions
├── docs/           # Documentation
├── outputs/        # Results, plots, reports
├── README.md       # Project description
└── your-project.Rproj

Connecting Git to RStudio Projects

Why Use Git?

Git helps you:

• Track changes to your code over time

• Collaborate with others

• Back up your work online

• Revert to previous versions when needed

Method 1: Add Git to Existing Project

If you already have an RStudio Project, use the usethis package:

library(usethis)
use_git()
use_github(private = TRUE)  # Set private = TRUE for private repos

Important: The private argument defaults to FALSE, making your repository public!

Method 2: Create Project with Git (Recommended)

This approach avoids common Git setup issues:

1. Create GitHub repository first:

   • Go to GitHub.com and create a new repository

   • Add a description

   • Choose public or private

   • Copy the HTTPS URL

2. Clone in RStudio:

   • Choose New Project > Version Control > Git

   • Paste the repository URL

   • RStudio will automatically name the project after your repository

   • Choose your subdirectory location

Working with Git in RStudio

The Git Panel

Once connected, you’ll see a Git tab in RStudio showing: - Modified files - New files - Files ready to commit

Using .gitignore

The .gitignore file tells Git which files to ignore. Common entries:

# Credentials and sensitive data
credentials.R
*.env

# Large data files
data/large-dataset.csv

# Temporary files
.Rhistory
.RData

The Git Workflow

1. Stage files: Check the boxes next to files you want to commit

2. Commit: Click “Commit” and write a descriptive message

3. Push: Upload your changes to GitHub

Viewing Changes

RStudio’s Git integration shows you: - Which files have been modified - Exactly what changed in each file (diff view) - When you right-click a file and select “Diff selected files”

This helps you: - Spot unintended changes or typos - Review your work before committing - Understand what’s changed since your last commit

Best Practices Summary

1. Always use RStudio Projects for better organization and portability

2. Connect Git early in your project lifecycle

3. Use consistent folder structures across projects

4. Write meaningful commit messages to track your progress

5. Regularly commit and push your work

6. Review diffs before committing to catch errors

See you in another tutorial!

In my new YouTube video, I show you how to use and customize interactive pivot tables for any dataset using the rpivotTable R package.

You will learn how to:

• create an interactive pivot table with 1 line of code;

• use the pivot table functionalities to explore any dataset;

• customize your pivot table with CSS and Javascript.

Watch the video now:

In this new YouTube video I show you how to fully customize your leaflet maps. As an example I reproduce an Swiss official choropleth map of Switzerland showing the top 5 most common surnames by commune.

You will learn how to:

• Search and download official Swiss data.

• Access official Swiss geographic data.

• Fully customize the Leaflet map, such as:

  • adding anything in tooltips.

  • customizing the legend.

  • controlling zooming and map limits.

  • creating an empty background.

Check out the video now:

In this new YouTube video I show you how to map Switzerland at a regional level using Eurostat geodata. But these steps can be used for any European country.

You will learn how to:

• Get counties/provinces/districts level data from any country in Europe.

• Join your own dataset to the geographic dataset.

• Build an interactive map with just 1 line of code.

• Create an interactive slider to compare two maps.

• Synchronize multiple interactive maps together.

Check out the video now:

In my new YouTube video, I show you how to use geocoding services such as Google Maps, Bing, Mapbox or OpenStreetMap to get the latitude and longitude of any location and plot them on an interactive map.

I just release a new YouTube video showing you how to access Spotify data to get the top 10 most listen songs and visualize them on a table.

You will learn how to:

• fully customize any element of a table and use pre-built themes.

• add any images programmatically from the Web.

• insert graphics such as bar plots, sparklines, etc.

• merge columns to better synthesis information.

I just published a new YouTube video showing you how to create a choropleth world map using World Bank unemployment data, and how to zoom on any specific region. As an example, we will visualize the European region only.

But of course, you can reuse the R code showed in the video with your own dataset on any region of your choice. You will see how easily it can be done using R.

At the end of the video I discuss some important points regarding the use of the scale and the color palette when creating a map, so be sure to watch the video until the end.

Don’t hesitate to write any question you have in the comments of the video.

I just published a new YouTube video showing the basics of working with Google Sheets data using R programming.

You will learn how to:

1. Connect R to Google Drive and list your existing Sheets;

2. Write and read Google Sheets from R

3. Append data to a Google Sheet;

4. Rename a worksheet;

5. Change file access permission (from private to public)

Check it out!

First we will scrape the data from Wikipedia, tidying the data, and build an interactive network of the main Marvel characters.

You can play with the final interactive network here: https://felixanalytix.com/vis/marvel-network.html

Learn how to make it yourself by watching my YouTube video ➡️

And learn this in a fun way?

In this new YouTube video, we will implement a simple-but-efficient method (a lexicon-based sentiment analysis) generally used to analyse consumer feedbacks, social medias or texts in surveys. But, to make it more fun, we will instead analyse the book Nineteen Eighty-Four from George Orwell.

Be sure to check it out! 👉

And that your R loops clean, validate and even merge your Excel files data into a single and consolidated dataset?

Well, you are lucky... My new video just teaches you how to do that 😉. And in only 5 minutes. So be sure to check it out:

👉https://youtu.be/BHdWYonrPAs

Be sure to check it out!! ➡️