The first event was the Make it Snappy challenge, held between departments at my workplace as part of National Science Week 2025. This was a fun opportunity to deliver a rapid-fire presentation in the vein of the Three Minute Thesis. Creating and rehearsing a presentation to be delivered in such a short timeframe was a new experience for me, and one that I really enjoyed. It was also fantastic to see some of the work being done by people in my office that is very different to my own.

Next up was the Avocado Production R&D Summit. I got to absorb a full day of presentations on key avocado research projects being conducted across Australia. This event did a particularly great job of approaching scientific research with an industry perspective.

Finally, I attended The Future of Hort Science Roadshow, hosted by the Australian Society of Horticultural Science with funding by the National Farmers’ Federation. I was fortunate enough to get the opportunity to present at this event and even received a travel award to do so. The other presentations were excellent, and the enthusiasm for horticulture among the attendees was palpable. The event also featured a fantastic keynote presentation by Honorary Professor Daryl Joyce, whom I have been fortunate enough to work with for the past two years.

Making any changes to the default build instructions supplied to the Docker Hub automated build system requires you to add a custom build hook in /hooks/build. Here is a custom build hook with code that, having read the docs, you might assume would add your supply chain attestations.

/hooks/build

#!/bin/bash

docker buildx build --sbom=generator=docker/scout-sbom-indexer:latest --provenance=mode=max -t $IMAGE_NAME --output=type=registry .

In reality, it’s not quite so simple. As pointed out in this helpful comment thread, the version of Docker running in Docker Hub’s automated pipelines is out of date, requiring you to use a custom builder.

/hooks/build

#!/bin/bash

docker buildx create --name container --driver docker-container --use
docker buildx build --sbom=generator=docker/scout-sbom-indexer:latest --provenance=mode=max -t $IMAGE_NAME --output=type=registry .

If you run this, you will see your build succeed in docker hub. But when you try to pull and run your latest image, you will notice that it doesn’t work. This is because the custom build instructions we are using automatically pushes to the registry, but the default push instruction included in the Docker Hub build pipeline is still being run immediately afterwards, overwriting your successful build. Fortunately, the solution is very simple – you just need to overwrite the default push instructions with a blank hook.

/hooks/push

#!/bin/bash

You should now have a working build pipeline with supply chain attestations.

The first step is establishing an SSH connection with the remote server on which your database is running, allowing you to interact with the database as though it were running on your own device. In an interactive session you could use the following code to establish an SSH connection and open a tunnel. The ssh_tunnel function will run indefinitely, leaving you unable to execute other code, but you can open a second R session and communicate with the database in that second session.

```{r}
session <- ssh::ssh_connect("username@targetserver.com")
ssh::ssh_tunnel(session, port = 3305, 
         target = "localhost:3306")
```

In the example above we map port 3306 on the remote server (the default port for MySQL) to port 3305 on our local machine. You will often want to use the same port on the local machine, but I find it is easier to keep track of examples where different values are used.

In a Quarto document you will need to run the SSH tunnel in the background. This is made easy with the callr package. The example below will run the SSH tunnel in a separate background process.

```{r}
rbg <- callr::r_bg(\() {
  session <- ssh::ssh_connect("username@targetserver.com")
  ssh::ssh_tunnel(session, port = 3305, 
           target = "localhost:3306")
})
```

You can now open a connection to the database as though it were running on your local machine on port 3305. Given that the SSH tunnel is opened in a separate process, I often find that if you attempt to connect to the database
directly after opening the tunnel you will encounter an error. To prevent this, I use Sys.sleep() to add a delay and allow the SSH tunnel to finish connecting before establishing the connection to the database.

It is easiest and safest to manage your database connections with a configuration file. Typically these are stored in a user directory, but I prefer to create them on a per-project basis.

.my.cnf

[groupname]
database="mydatabase"
host="localhost"
port="3305"
user="username"
password="mypassword"

You can use the a conf file setup like above to connect to the database.

```{r}
con <- DBI::dbConnect(RMySQL::MySQL(), 
                 group = "groupname", 
                 default.file = ".my.cnf")
```

You can now access the database using DBI in R.

If you are already an experienced SQL user, you can write SQL directly in Quarto using your established connection. The ability to switch between R, Python, and even Julia is marketed quite heavily by the Posit team, while this SQL functionality seems much more obscure.

```{sql}
#| connection: "con"
select * from mytable;
```

You can even output of an SQL query to an R object, in this example named df, allowing you to seamlessly integrate SQL queries and R code.

```{sql}
#| connection: "con"
#| output.var: "df"
select * from mytable;
```

You should now be set to query with confidence.

When I decided to add dark mode to my Quarto website, Dracula was the obvious choice. But, given the wide-ranging support for the theme, I was surprised to discover there was no pre-packaged Bootstrap theme which I could plug into Quarto. Of course, I wasn’t going to let that stop me!

Starting with the Darkly theme from Bootswatch as a base, I customised the theme to incorporate the Dracula palette using the handy Bootstrap Live Customizer tool, before exporting the resulting LESS code and converting it to the SCSS required by Quarto. I had to remove a few variables which seemed to cause issues when rendering. After a few additional tweaks, I was left with a Dracula themed site that felt like home. You can access the SCSS file here. If you’re reading this post through an aggregator, you can see it in action on my original post.

There are a few things to consider when adding the Dracula theme to your own Quarto site. Not all viewers prefer the dark mode experience, so I prefer to let the user decide. In the snippet from my site-wide YAML configuration below, the user is offered a choice between a light and dark mode (Darkly + Dracula), but the website defaults to the user’s system preference. I also specified a custom font to be used across both themes, as I wanted to minimize changes besides colour when switching between themes. As a final touch, specify Dracula code highlighting if you are going to be including code chunks. You may optionally include a styles.css file in the root directory of the project,
incorporating other style changes that are applied across both themes.

---
format:
  html:
    respect-user-color-scheme: true
    theme: 
      dark: [darkly, styles-dark.scss]
      light: sandstone
    header-includes: |
      <link rel="stylesheet" media="screen" href="https://fonts.googleapis.com/css2?family=Fira+Sans" type="text/css"/>
      <link rel="stylesheet" media="screen" href="https://fonts.googleapis.com/css2?family=Fira+Code" type="text/css"/>
    mainfont: "Fira Sans"
    monofont: "Fira Code"
highlight-style: Dracula
---

Hopefully this will be of use to some other Dracula diehards out there. I’m sure I will continue to tweak the SCSS file as I spot opportunities for improvement.

There are a plethora of great books that are widely recommended for the beginner R user, but I many users often find their skills plateauing once they learn just enough to get by on a day-to-day basis. These are some of the books that helped me to break through that plateau and take full advantage of R.

As an example dataset I’ll be using chip_dataset.csv, downloaded from Vercel. Redistribution of the dataset is not permitted.

Let’s create a rough figure, and see how we can improve it in a few simple steps.

```{r}
#| dev: "CairoPNG" 
#| fig-cap: "A rough figure"

library(ggplot2)
library(dplyr)
library(lubridate)

chips <- read.csv("chip_dataset.csv")

chips <- chips |> 
  mutate(Date = mdy(Release.Date),
         transistors = as.numeric(Transistors..million.)) |>
  filter(Foundry != "" &
           Type == "GPU" &
           !is.na(Date) &
           !is.na(transistors))

chips |> 
  ggplot(aes(x = Date, 
           y = transistors, 
           color = Foundry)) +
    geom_point()
```

```{r}
#| dev: "CairoPNG" 
#| label: feature-image
#| fig-cap: "The final figure"

library(hrbrthemes)
library(sysfonts)
library(viridis)
library(scales)

font_add_google("Roboto Condensed")

chips |>
  ggplot(aes(x = Date, y = transistors, color = Foundry)) +
  geom_point(alpha = 0.2) +
  geom_smooth(method = "lm", se = FALSE, alpha = 0.5) +
  scale_colour_viridis_d(option = "H", direction = -1) +
  scale_y_log10(labels = label_number()) +
  theme_ipsum_rc(axis_title_size = 12) +
  theme(legend.position = "bottom",
        panel.grid.major.x = element_blank(),
        panel.grid.minor.x = element_blank()) +
  labs(y = "Transistors (millions)",
       title = "GPU Transistor Count by Release Date",
       subtitle = "Data from https://chip-dataset.vercel.app/")
```