Dr Tom Palmer

How Posit's Public Package Manager manylinux_2_28 repository can help you if your R project is stuck on Ubuntu Focal Fossa

Thu, 12 Feb 2026 00:00:00 +0000

Introduction

I am a massive fan of repositories making binary R packages available. This includes the canonical CRAN repositories, r-universe, r2u, and the Posit (Public) Package Manager, and there are others. R-universe is outstanding because it builds binaries of GitHub only packages. The Posit Public Package Manager is outstanding due to its incredible breadth (it makes binaries for 14 Linux distros) and also its depth (its almost daily snapshotting service is remarkably useful for quickly making reproducible R environments).

Today I wanted to highlight how the manylinux_2_28 packages in the Posit Public Package Manager helped me out. Posit released this in June 2025. Ironically, I was using another Posit service, Posit Cloud (formerly RStudio Cloud). Within this I have quite a few projects in workspaces which are over 3 years old. Behind the scenes these are running on Ubuntu Focal Fossa Linux. I believe that if I create a new Posit Cloud RStudio project that will be running on Ubuntu Noble Numbat and so users of new projects won’t need this tip.

Unfortunately, Focal Fossa is out of support (except if you have Ubuntu Pro) and hence Posit have removed their Focal repository packages from the Posit Public Package Manager, which is fair enough. Within the Posit Cloud project workspace Posit kindly make available a private version of what I think was that Focal repository. However, for reasons I don’t fully understand a fair number of the packages I required weren’t built as binaries.

That got me thinking, could the manylinux_2_28 packages help here? In the name the 2.28 refers to the minimum version of the glibc library that the Linux distro needs to come with. I realised that I didn’t know what version of glibc Ubuntu Focal Fossa came with. A quick

ldd --version

revealed

ldd (Ubuntu GLIBC 2.31-0ubuntu9.17) 2.31
Copyright (C) 2020 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Written by Roland McGrath and Ulrich Drepper.

And hence I was in luck as version 2.31 is after 2.28. Therefore, in my Posit Cloud workspace I simply switched my syntax to installing packages to

install.packages(
  'tidyverse',
  repos = 'https://packagemanager.posit.co/cran/__linux__/manylinux_2_28/latest'
)

and all the packages came in as binaries. If you are not running this from within RStudio your syntax would need to be the following as per the setup page

options(repos = 
  c(
    CRAN = sprintf("https://packagemanager.posit.co/cran/latest/bin/linux/manylinux_2_28-%s/%s",
    R.version["arch"], 
    substr(getRversion(), 1, 3))
  )
)
install.packages('tidyverse')

My other solution could have been to create a new RStudio project, which as I said would be running on Noble Numbat.

Summary

In summary, manylinux_2_28 binary packages in the Posit Public Package Manager can be used in Ubuntu Focal Fossa. Thanks again to Posit for this great resource.

My #GitHubUnwrapped 2025!

Fri, 05 Dec 2025 00:00:00 +0000

My #GitHubUnwrapped 2025!

Made with https://www.githubunwrapped.com/.

Executable Python scripts with inline metadata and why friends don't let friends install R packages with remotes::install_github()

Wed, 10 Sep 2025 14:00:00 +0000

Creating self-contained executable Python scripts for rendering Quarto documents using the Jupyter engine

Tue, 02 Sep 2025 00:00:00 +0000

Introduction

In previous posts I have covered creating effectively multi-engine Quarto documents and also how to use uv virtual environments for the nbstata Jupyter kernel to run Quarto documents with Stata code. Hence by trivial extension we can use uv to manage the virutal environments for running Quarto documents using the jupyter: python3 engine.

The slight inconvenience about this approach when you are working on a collaborative project with new Python users is that you end up leaving a README or shell script with the required commands to activate the environment, install the nbstata kernel, and run Quarto. I sense this management of the virutal environment is a pain point for new Python users - who are likely wondering what on earth a virtual environment is. So I have been looking for a way to simplify this process for them.

A recent post by Matt Dray about using uv to run self-contained executable Python scripts got me thinking. Could I produce a similar self-contained executable Python script to perform the rendering for Quarto documents using the Jupyter engine. Then my colleagues would only need to call the script as an executable at the command line. This would avoid them the trouble of managing the virtual environment.

The self-contained executable Python script

I came up with the following Python script.

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.9"
# dependencies = [
#     "jupyterlab>=4.4.3",
#     "jupyterlab-stata-highlight2>=0.1.2",
#     "nbstata>=0.8.3",
# ]
# ///
import subprocess

cmd0 = "python -m nbstata.install --sys-prefix"
retval0 = subprocess.call(cmd0, shell=True)
print('returned value:', retval0)

cmd1  = "quarto render --profile stata-questions"
retval1 = subprocess.call(cmd1, shell=True)
print('returned value:', retval1)

cmd2  = "quarto render --profile stata-solutions"
retval2 = subprocess.call(cmd2, shell=True)
print('returned value:', retval2)

The first line, the shebang ensures it is run by uv run
The metadata defining the Python environment is declared between the
```
# /// script
# ...
# ///
```
- If you don’t use Stata, say you are using the jupyter: python3 engine then you can delete the jupyterlab-stata-highlight2 and nbstata entries and the first group of 3 lines for cmd0.
- If you use additional Python packages in your code then you need to add them to the list.
Then comes the actual code. These are simply system calls using the subprocess module. You can amend the number of calls and the calls themselves inside the string quotes as required. I am recreating some of the rendering commands in my recent post about using Quarto profiles for tutorial documents. It’s worth pointing out that I haven’t used the Python quarto package here as it’s currently slightly too limited for my use (I’m not sure it can render profiles).

Save the script in a file, say render, then make it executable with

chmod +x render

Then all my colleagues need to do is run it with

./render

Of course uv and Quarto need to be installed and be on their PATH, and Stata needs to be installed locally when using that. For my colleagues using Windows, they need to run this from a Git Bash shell rather than from Powershell or CMD shell (for the shebang line to work).

If you are only using the Quarto knitr engine then you don’t need this script because you don’t need Jupyter.

And for more information about uv Python scripts, the full documentation is here.

Summary

I have shown how to make a self-contained executable Python script to render Quarto documents using the Jupyter engine which automatically manage their own virtual environment. This means users don’t have to manage the virtual environment themselves, which can be a pain point for new Python users.

Seven accessibility tips for Quarto and R Markdown users

Fri, 15 Aug 2025 00:00:00 +0000

Introduction

When teaching, for my practicals/tutorials and for about half of my lectures I find myself preparing them using R Markdown and laterly Quarto. I enjoy preparing the material in R Markdown and Quarto because it gives me a reproducible way of regenerating my material every year and I can track changes in the Rmd/qmd files very precisely with Git.

Recently, the subject of accessibility has become more prominent within Universities. In the UK, and in many other countries, we are legally obliged to produce accessible learning materials that do not disadvantage disabled students.

My University uses Blackboard for its online learning environment (OLE)/learning management system (LMS). There are other OLEs, e.g., Moodle, Canvas, etc. They all work in essentially the same way in that they provide a website per Unit/Module/Course within a secure online system.

Every document I upload into Blackboard receives an accessibility score (out of 100%) and each module I teach receives an overall accessibility score. My University uses Anthology Ally Accessibility Report to generate these scores. My university doesn’t have a rule about what’s an acceptable score for either a document or a course.

It turns out accessibility is sometimes abbreviated to a11y, which like k8s (for Kubernetes), is a numeronym, where the 11 stands for the 11 letters in between the starting a and the ending y of accessibility.

I should say there are many guides to accessibility for HTML documents online, and indeed for R and R Markdown there are at least two packages on CRAN, accessrmd and accessr, addressing accessibility issues. Also I have not covered topics such as choosing an accessible color palette in say ggplot2.

What follows is a set of tips which help improve the accessibility score for individual documents and hence your overall module accessibility score.

Tip 1: Replace all pdfs with docx, pptx, or html documents

For a pdf to get a high accessibility score it needs to be a special type of pdf called a ’tagged pdf’, otherwise it will get a very low score (approx. 6%).

As I will show in the following tips, it is much easier to make Word, Powerpoint, and html documents accessible. If you are looking for the most effective boost to your accessibility scores simply remove all pdf documents from your site and replace them with Word, Powerpoint, or html documents.

Tip 2: Add alt text to all figures

I guess like many R users the first I remember hearing about accessibility was that there is this thing called alt text and it’s best practice for html documents to provide alt text summaries of every image they contain. Then screen readers have a description of the image for visually impaired readers.

It turns out that other types of document can also hold alt text for images; including Word, Powerpoint, and pdf documents.

Let’s say we have a Quarto (or R Markdown) document which we render to docx and html output formats. To add alt text to figures in the html document we can use the fig-alt chunk option (fig.alt in R Markdown). However, it turns out that alt text for a Word document is taken from the fig-cap chunk option (fig.cap in R Markdown). Therefore, I specify both fig-alt and fig-cap chunk options in all code chunks generating figures.

```{r}
#| fig-cap: Kaplan-Meier survival curve.
#| fig-alt: Plot of a Kaplan-Meier survival curve.
# code to generate plot
```

Tip 3: (The surprising headache that is) Creating tagged pdfs 😬🤯

It is possible for a pdf to obtain a perfect accessibility score; but as I said above it must be a tagged pdf.

You can check if a pdf has tags by opening it in Adobe Acrobat Reader then bringing up the document properties window. The information is in the bottom left of the Description tab (on Windows I found that SumatraPDF also reported that information but on macOS I found I couldn’t see this reported in the Preview app).

It turns out that we can create tagged pdfs in a few ways;

by exporting a Word or Powerpoint document to pdf within those programs
- note when exporting to pdf on macOS, users must select the Best for electronic distribution and accessibility… option (the Best for printing option does not generate tagged pdfs)
- Word and Powerpoint for Windows and Word and Powerpoint online export tagged pdfs by default
by printing html documents to pdf (Print | Save as pdf) in Chrome (and the other Chromium based browsers such as Edge)
- In my testing I find that by default Safari and Firefox do not generate tagged pdfs
The paid for professional version of Adobe Acrobat allows users to add tags to pdfs, but I don’t have that, and I assuming you don’t either.
And I should note that within Blackboard itself Ally can generate a tagged pdf from Word and Powerpoint documents, under the Download Alternative Formats option for a file.

The surprise here is that pdf documents produced by LaTeX and typst by default do not (yet) generate tagged pdfs. Therefore, do not render to pdf/typst output formats in Quarto nor pdf_document in R Markdown (nor pdf_document2 in bookdown).

Generating tagged pdfs in LaTeX

It turns out it is possible to generate a tagged pdf from LaTeX, but this is extrememly inconvenient from R Markdown and Quarto. First use Quarto/R Markdown to generate the TeX file of your document, e.g. in Quarto specify either

format:
  pdf:
    keep-tex: true

or the latex output format.

format:
  latex

You then require the following LaTeX packages.

tinytex::tlmgr_install(c('latex-lab', 'pdfmanagement-testphase', 'tagpdf', 'luamml'))

You then need to amend the very top of your TeX file to have a \DocumentMetadata{tagging=on} entry. And possibly using the unicode-math package is helpful. The beginning of your TeX file will look like the following.

\DocumentMetadata{tagging=on}
\documentclass{article}
\usepackage{unicode-math}
\begin{document}
% the rest of your document ...
\end{document}

When I tried this I found that compiling with LuaLaTeX did generate a tagged pdf.

lualatex mydocument.tex

But I cannot face going through this hassle for every document I produce. So the slightly unexpected take home message here is that if you want to give your students a pdf document, the most convenient way to produce a tagged pdf is to render your Quarto document to docx or html and then export the pdf from within either Word or Chrome or let Ally do the conversion for you.

Tip 4: Improving table accessibility

I find that tables generated using the Markdown syntax generate warnings in Ally Accessibility Checker. It reports it can’t find the header row. However, I find that tables generated using the gt package, and other table packages usually pass. So I avoid creating tables using Markdown syntax.

Tip 5: Different accessibility checkers can report different results

Microsoft has built an accessibility checker into alot of its Office suite. You can access this in Word and Powerpoint from the Review tab then Check Accessibility.

Compared to Ally Accessibility Checker I find this checks for more conditions. For the items they both check I find that most of the time they agree. But sometimes they don’t agree, e.g., the Microsoft checker reported that the slide numbers in a Powerpoint deck were ok, whereas Ally Accessibility Checker reported that they failed its colour contrast check (even though they were black text on a white slide).

Tip 6: Improving the accessibility of custom Word document templates

If you want to use a custom template Word document for your docx output it needs to be based on the underlying Pandoc docx template. You can obtain that by running

pandoc --print-default-data-file reference.docx > reference.docx

You can then adjust the formatting of the various styles in Word in the Styles Pane, and also if you are in the UK/EU you can amend the layout size from US Letter paper to A4.

Then run the Microsoft Accessibilty checker on this document (Review tab | Check Accessibility) and Word will give you the option to upgrade the format of the document so that it can run, so click the Convert button when prompted.

Then if you’ve added an image to the document header you can add alt text to it. Then resave the document. Then specify the use of the reference document in your Quarto YAML header.

format:
  docx:
    reference-doc: reference.docx

Tip 7: Uploading Quarto/complex html documents into Blackboard Ultra

My university has upgraded to the latest version of Blackboard - Ultra. Prior to this upgrade I had no trouble uploading any type of document. But now if I try to upload html documents with embedded resources generated from Quarto the upload animation hangs (the 3 squares on the right of the screenshot below simply keep animating) and the file is not uploaded.

It turns out this is because Blackboard scans every document we upload, which it calls its content sanitization check. For some reason Quarto html documents, including revealjs html slide decks, are now too complex and fail this check. Annoyingly, Blackboard does not emit any error message to tell us this. However, there is a workaround.

First, put your html file into a zip archive
Then from within your module site, go to Content Collection when adding an item
Then select Upload | Upload Zip Package (choosing any other option will fail)
Make sure to select the button to overwrite an existing file with the same name
And click Submit and that’s it.

This is the only way I can find to bypass the content sanitization check. Note if you attempt to upload the zip archive from your Content Collection accessed not from within the course site - as per screenshot below (don’t go here!) - the upload will also fail (confusing I know!).

Summary

I have described 7 hopefully helpful tips about how to improve the accessibility scores for documents produced from Quarto and R Markdown. Using these tips I have increased the accessibility score for my module from 67% for last year’s site to 98% for this year’s site.

I hope that you have similar success.

Creating tutorial worksheets: Quarto profiles for the win!

Sun, 06 Jul 2025 00:00:00 +0000

Introduction

I previously posted about creating tutorial worksheets for 4 different Quarto engines (for R, Python, Stata, and Julia) using conditional content. However, that approach is a bit hacky and I wasn’t very happy with it.

Thanks to a vignette by Christophe Dervieux in the quarto R package I realised there is a more convenient, and less hacky, way to create tutorial documents using Quarto profiles. I don’t use the dynamic metadata approach in the vignette to achieve my solution but it led me to the relevant Quarto documentation page and I discuss it at the end of this post.

My aim is the following

To have a single Quarto document from which both the question and solution documents can be rendered for a tutorial.

As a reminder, as I showed in my previous post, this has been possible to achieve for a long time with R Markdown and knitr thanks to the brilliant work of Yihui Xie, because they allow programmatic chunk options. Therefore, implementing this in a Quarto document using the knitr engine is also straightforward and I won’t repeat it in this post. However, it is the three other Quarto engines (for Python, Stata, and Julia) that I am interested in which are problematic because as far as I know they don’t allow programmatic chunk options and they don’t have the equivalent of the ! expr ... YAML tag literal.

Quarto profiles

Quarto profiles are introduced on this page of the Quarto documentation. Specifically, we shall make use of conditional content dependent upon profile.

First we will create a simple default Quarto profile file _quarto.yml which will simply contain the following.

execute:
  eval: true

(This is because I usually have an R version of the tutorial in the same directory using programmatic chunk options, so I don’t want to set a default that is language specific nor will affect anything in the R Quarto documents.)

Next for each language I will make profiles for the questions output and the solutions output in appropriately named YAML files (I just show the Python files as the other two just have Stata/Julia substituted in the appropraite places).

Questions and solutions profiles for Python

_quarto-python-questions.yml

project:
  render:
    - tutorial-python.qmd
title: 'Questions document: Python version'
execute:
  eval: false
format:
  html:
    output-file: "tutorial-python-questions"
    output-ext:  "html"

_quarto-python-solutions.yml

project:
  render:
    - tutorial-python.qmd
title: 'Solutions document: Python version'
format:
  html:
    output-file: "tutorial-python-solutions"
    output-ext:  "html"

Then our tutorial Quarto Python document, tutorial-python.qmd, will look like the following.

---
format:
  html:
    embed-resources: true
jupyter: python3
---

## Question 1

Question text.

```{python}
print("The code which is echoed in questions and evaluated in solutions.")
```

::: {.content-visible when-profile="python-solutions"}
The text for the solutions.
:::

We see the use of the conditional content based upon profile for the text of the solutions, and we could included additional code chunks in these conditional content divs.

We repeat this for the other 2 tricky Quarto engines, engine: julia and jupyter: nbstata, including making profile yaml files for each engine and the respective tutorial-{stata/julia}.qmd Quarto documents.

Then we make a shell script with our render commands.

quarto render --profile python-questions
quarto render --profile python-solutions

quarto render --profile stata-questions
quarto render --profile stata-solutions

quarto render --profile julia-questions
quarto render --profile julia-solutions

And because I have an R version using parameters my shell script usually begins.

quarto render tutorial-r.qmd -P solutions:false -o tutorial-r-questions.html
quarto render tutorial-r.qmd -o tutorial-r-solutions.html

And that’s it.

You can find the full source code in my example repo here and their rendered output can be viewed from here. This repo also contains a tutorial document including the 4 languages in the same document using the embed shortcode as I described in another previous post. A screenshot of the questions and solutions documents from this approach is shown above.

An honorable mention about dynamic metadata

When I started reading the quarto R package vignette I began trying to use dynamic metadata to achieve the result above. Dynamic metadata involves writing extra YAML blocks into your Quarto document which can include programmatically specified values of parameters, which can then be used by including conditional content by matching against them. I found that I could achieve what I wanted if I used the --metadata-file argument to quarto render with the settings included in their own YAML files except for modifying the execute state of the Quarto document, it seems that must be specified in the first YAML block/header. And this cannot be controlled by the --execute and --no-execute flags to quarto render because one needs the code which generates the additional YAML blocks to be run (with thanks to Christophe for pointing this out to me).

For Quarto documents using the knitr engine, the R package vignette shows how to use the new write_yaml_metadata_block() function within an R code chunk with output type asis to write the YAML block. In case it is useful to anyone, below I show examples of how to write the YAML blocks in each of the three other engines I have been using. (Admittedly this is not needed if one uses the --metadata-file argument to quarto render in which these settings are included in their own YAML files.)

Python (jupyter: python3)

```{python}
#| include: false
#| tags: [parameters]
solutions = 'true'
```

```{python}
#| include: false
from IPython.display import Markdown
ymltxt = f"  solutions: {solutions}"
if solutions == 'true':
    titletxt = "title: Solutions document"
else:
    titletxt = "title: Questions document"
```

`{python} Markdown("---")`
`{python} Markdown("params:")`
`{python} Markdown(ymltxt)`
`{python} Markdown(titletxt)`
`{python} Markdown("---")`

::: {.content-visible when-meta="params.solutions"}
```{python}
print("A solution, which is hidden in questions")
```
:::

Stata (jupyter: nbstata)

```{stata}
*| include: false
local solutions : env SOLUTIONS_STATA
scalar ymltxt = "  solutions: `solutions'"
if "`solutions'" == "true" {
  scalar titletxt = "title: Solutions document"
}
else {
  scalar titletxt = "title: Questions document"
}
```

`{stata} "---"`
`{stata} "params:"`
`{stata} scalar(ymltxt)`
`{stata} scalar(titletxt)`
`{stata} "---"`

::: {.content-visible when-meta="params.solutions"}
```{stata}
display "A solution, which is hidden in questions"
```
:::

Julia (engine: julia)

```{julia}
#| tags: [parameters]
```

```{julia}
#| echo: false
#| output: asis
println("---")
if solutions
  println("title: Solutions document")
  ymltxt = "  solutions: true"
else
  println("title: Questions document")
  ymltxt = "  solutions: false"
end
println("params:")
println(ymltxt)
println("---")
```

::: {.content-visible when-meta="params.solutions"}
```{julia}
println("A solution, hidden in questions")
```
:::

Summary

I have shown how to create Quarto profiles for creating tutorial worksheets; one for the questions and one for the solutions from the same Quarto document; for several Quarto engines (engine: knitr, jupyter: python3, jupyter: nbstata, and engine: julia). I have also shown how additional metadata may be written into your Quarto document in these engines which can be used in conjunction with parameterised documents and conditional content.

Investigating running R on RISC-V thanks to r-base on Ubuntu

Tue, 10 Jun 2025 00:00:00 +0000

Introduction

I was interested to see whether and how well R would run on the new RISC-V architecture.

A while ago I read that RISC-V is now a first class architecture for Ubuntu.

This got me thinking, instead of having to build R from source maybe the r-base package might be available for RISC-V. It turns out that this is indeed the case, the architecture we are interested in is riscv64. The launchpad page for r-base is here. Clicking through the subpages for each version of Ubuntu I can see that R is available for RISC-V from Ubuntu Focal Fossa onwards (for which the version of R is 3.6.3; and the latest version of Ubuntu has the current version of R of 4.5.0).

Why do this? I have no immediate need for this. However, there are now quite a few affordable RISC-V single board computers available, and so a similar argument holds to that made by the R4Pi (R for the Raspberry Pi project) that running R on such affordable machines is a great benefit because it opens R up to a whole new user base and whole new set of low power use cases.

Emulating RISC-V on an Apple Silicon Mac

I don’t have a RISC-V computer, therefore, I needed to use emulation.

My setup is that I’m on an Apple Silicon M4 MacBook Air. I thought this might be promising to use because this has an ARM processor which is a reduced instruction set architecture, as is RISC-V.

I wondered whether to try UTM or QEMU. I tried UTM first but I couldn’t make any progress. So I found a tip online saying that RISC-V Ubuntu could be launched under QEMU on Ubuntu Linux using the following command.

qemu-system-riscv64 \
  -machine virt \
  -nographic \
  -m 12288 -smp 4 \
  -bios /usr/lib/riscv64-linux-gnu/opensbi/generic/fw_jump.elf \
  -kernel /usr/lib/u-boot/qemu-riscv64_smode/uboot.elf \
  -device virtio-net-pci,netdev=eth0 \
  -netdev user,id=eth0,hostfwd=tcp::2222-:22 \
  -drive file=ubuntu-24.10-preinstalled-server-riscv64.img,format=raw,if=virtio

Firstly one needs to obtain the Ubuntu img. Following this incredible guide by Canonical we can choose one of the three versions of Ubuntu listed (Noble, Oracular, and Plucky).

The image downloads as an .img.xz archive, which you can extract by installing xz (I use Homebrew for system packages on macOS)

brew install xz

and decompressing with

xz --decompress ubuntu-24.10-preinstalled-server-riscv64.img.xz

The extracted file is about 4GB, but later on I realised I needed a slightly larger harddisk for the virtual machine, so I increased it to 8GB with the following command.

qemu-img resize ubuntu-24.10-preinstalled-server-riscv64.img 8G

I then realised that I needed QEMU on my Mac. Again Homebrew to the rescue with the following command.

brew install qemu u-boot-tools

(Admittedly I don’t think I ended up using the u-boot-tools.) Next I needed the two files; fw_jump.elf and uboot.elf. I had a look in /opt/homebrew/Cellar/qemu/10.0.2/ but I couldn’t work out if they are in there or not (there are some zip archives in some subdirectories). There are some official documentation pages here and here but I couldn’t follow them. I then found a comment that said you can copy them from an Ubuntu installation, which I implemented in Docker.

docker run -it --rm --platform linux/arm64 \
  -v $PWD:/home ubuntu:24.04 bash /home/copy-files.sh

where copy-files.sh contains

apt update
apt upgrade -y 
apt install -y opensbi qemu-system-misc u-boot-qemu
cp /usr/lib/u-boot/qemu-riscv64_smode/uboot.elf /home/uboot.elf
cp /usr/lib/riscv64-linux-gnu/opensbi/generic/fw_jump.elf /home/fw_jump.elf

This saves the two files to the current working directory, so I could modify my call to qemu-system-riscv64 to be as follows.

qemu-system-riscv64 \
  -machine virt \
  -nographic \
  -m 12288 -smp 4 \
  -bios fw_jump.elf \
  -kernel uboot.elf \
  -device virtio-net-pci,netdev=eth0 \
  -netdev user,id=eth0,hostfwd=tcp::2222-:22 \
  -drive file=ubuntu-24.10-preinstalled-server-riscv64.img,format=raw,if=virtio

After a couple of seconds you obtain a GRUB screen in which you select the default of Ubuntu. Then after a further approx. 20 seconds of screen output, a little bit to my surprise this worked and I was presented with the login screen to Ubuntu server. The default username is ubuntu and the default password is ubuntu. On login you are immediately prompted to change the password but then you’re in.

So next it’s essentially standard Ubuntu commands to update the system and install r-base. I also install r-base-dev to obtain the necessary compilers to build any source packages containing code which needs to be compiled.

sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get install -y r-base r-base-dev

Then we launch R.

From this point on everything I tried simply worked. I installed data.table from source. Then slightly more obscurely, I tried out a trick from Jeroen Ooms who said that if an R package only contains R code then its binary version will install under any architecture. I have a few R packages in my r-universe that only contain R code, my example installed as expected (note this was built on x86_64 Ubuntu Linux but contains no source code which needs to be compiled).

install.packages('tmsens', repos =
  'https://remlapmot.r-universe.dev/bin/linux/noble-x86_64/4.5/')
#> * installing *binary* package ‘tmsens’ ...
#> * DONE (tmsens)
#> 
#> The downloaded source packages are in
#> 	‘/tmp/RtmpYqwF8W/downloaded_packages’
library(tmsens)
#> Warning message:
#> package ‘tmsens’ was built under R version 4.5.0
help(package = 'tmsens')
#> 
#>                 Information on package ‘tmsens’

I admit I haven’t tried many features here but I am really impressed with Ubuntu packages being available for RISC-V.

Once you are finished using R, exit R as usual and to shutdown the Ubuntu server issue the following.

sudo poweroff

Summary

I have shown how to install and run R on Ubuntu Server for RISC-V under QEMU emulation. Thanks to Canonical’s support for RISC-V and the maintainers of the r-base and related packages the experience of running R on RISC-V is already excellent.

How to widen the accordion on a Blackboard page

Fri, 30 May 2025 00:00:00 +0000

Introduction

My university uses the Blackboard online learning environment (there are others, e.g., Moodle and Canvas, etc.). On several of the Unit (aka Module) and short course sites we have an accordion containing the table with the timetable of the teaching. Unfortunately I find the default width too narrow.

This post shows how to make this accordion element wider.

Widening the accordion

First we need to work out what type of element it is. To do this in Google Chrome right click on a part of the accordion and click Inspect.

We can see that the accordion is a div of class deo-accordion. And we can see that it’s max-width is currently set to 40em which is 640 pixels.

Therefore to modify this we need to write the CSS for this with a larger max-width. It turns out Blackboard does not allow us to put CSS in a <style> tag directly in a component’s source code. Therefore, we put the following in a file called mystyles.css. The 60em is equivalent to 960 pixels.

.deo-accordion {
  max-width: 60em;
}

We then upload this file to our Blackboard site’s Content area. Once uploaded we obtain the Permanent URL of the file by clicking the dropdown arrow to the right of the filename and selecting 360° View. Copy the permanent URL to the clipboard.

Within the content of the item on your Blackboard page which contains the accordion, click edit, then click the <> symbol to enter editing source code mode. At the bottom of the code enter the following line – replacing the PERMANENT_URL with what we just copied and save the changes.

<link href="PERMANENT_URL" rel="stylesheet">

And you should find that you have a wider accordion.

Summary

I have shown how to widen the accordion on a Blackboard page with some simple CSS.

Some more R, Git, and R Markdown and Quarto tips

Wed, 07 May 2025 12:00:00 +0000

Running the nbstata Jupyter kernel within a uv virtual environment

Tue, 29 Apr 2025 00:00:00 +0000

Introduction

Any new project using Python or Jupyter is very strongly recommended to use a virtual environment. A virtual environment is a directory (usually at the top level; often called either .venv or venv) within your project directory which contains the dependency Python packages and perhaps the Python installation (or pointers to the Python installation on your system).

There are many Python project managers, in this post I will use the new and extremely fast project manager uv. I will show how to use the nbstata Jupyter kernel by Tim Huegerich within a uv virtual environment on macOS, Windows, and Linux. The aim is to be able to conveniently and reproducibly render Quarto documents using the jupyter: nbstata engine from within the virtual environment.

At this point it’s worth saying that I am a contributor to the excellent Statamarkdown R package by Doug Hemken. This can be used in Quarto documents using the knitr engine. In this post I’ll be using nbstata because nbstata uses pystata which is StataCorp’s official Python package (included in each Stata installation) and is their official way of integrating Stata in Python. As such pystata and hence nbstata have more features than Statamarkdown can provide.

And it is worth emphasizing how useful virtual environments are because it is very easy to get oneself in a complete mess with regards Python, as you will likely end up with many different versions installed. Chaos can then accidentally ensue regarding which versions of dependency packages your different projects require given a certain Python version, as always XKCD have a comic illustrating the problem.

XKCD 1987, Python Environment. XKCD license

Setup basics

On your machine you need to have

Stata installed and know the location of the installation
- and check that within the installation there is the utilities directory containing the pystata directory
uv must be installed, see its docs for installation instructions
to render Quarto documents you need Quarto installed
and of course a text editor and a terminal.
On Windows I would recommend using Git Bash as your shell (this is bundled with Git for Windows) for running the setup script in the next section.

A shell script to setup the uv virtual environment

What follows are the shell commands we need to run to setup our virtual environment. The script is for macOS but I have included comments in the places where amendments are required for either Windows or Linux. I have also included this script in a repository (in fact I have included a script per operating system).

Note that currently on macOS and Linux there cannot be any spaces in the filepath to your virtual environment. And you might need to amend some of the paths, say if you have a different version of Stata or if it’s installation location is different.

On Linux we need to ensure that the directory containing our stata/stata-mp binary is on PATH.

# export PATH=$PATH:/usr/local/stata18

We then need to ensure that our Python installation will be able to find the pystata package. We can do this by defining the PYTHONPATH environment variable.

# Required so Python can find pystata package
export PYTHONPATH=/Applications/Stata/utilities
# Linux: export PYTHONPATH=/usr/local/stata18/utilities
# Windows: export PYTHONPATH="C:/Program Files/Stata18/utilities"

We then setup the virtual environment. This will create a directory in our project called .venv. I prefer to explicitly set the version of Python I am using.

uv venv --python 3.13

We then activate the virtual environment

source .venv/bin/activate
# Windows: source .venv/Scripts/activate

Now we can install the required Python dependency packages as per the nbstata docs.

# Install nbstata dependency Python packages
uv pip install jupyterlab nbstata jupyterlab_stata_highlight2

# Additional Python packages if using parameterised Quarto documents
# uv pip install papermill python-dotenv jupyter-cache

Then we setup the nbstata Jupyter kernel

python -m nbstata.install

The nbstata docs states that the --sys-prefix flag may be required in a virtual environment but I haven’t found that to be the case.

Then we run commands to do our actual work; for example rendering a Quarto document using the jupyter: nbstata engine. An example Quarto document, say index.qmd, could be:

---
title: My example nbstata document
jupyter: nbstata
---

```{stata}
display "Hello, World!"
```

quarto render index.qmd

Note that Quarto documents using the nbstata kernel can also be embedded within other Quarto documents, as I have described in a previous post.

And that’s it. When you have finished your work you can deactivate the virtual environment

deactivate

Recording this as a project with pyproject.toml and uv.lock files

And of course we can go a step further by setting this up as a proper Python project. This will have a pyproject.toml file to record the dependencies and a uv.lock file to record their exact versions. To do this run

uv init

You can delete the main.py file that’s created here, but commit everything else into your repo. Then add the dependencies with

uv add jupyterlab nbstata jupyterlab_stata_highlight2

You will see these are entered into the pyproject.toml and uv.lock files. The pyproject.toml file will now look something like this (I have edited the description)

[project]
name = "nbstata-uv-setup"
version = "0.1.0"
description = "This project demonstrates how to use the nbstata Jupyter kernel in a uv virtual environment, so that one can render Quarto documents using this engine."
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
    "jupyterlab>=4.4.2",
    "jupyterlab-stata-highlight2>=0.1.2",
    "nbstata>=0.8.2",
]

Commit these files into your repo.

At a later date you can restore this environment by running

uv sync
# which creates the .venv
# Then activate the virtual environment, etc
source .venv/bin/activate
# Windows: source .venv/Scripts/activate

You find out more about uv project commands in its documentation.

Summary

I have shown how to setup and run the nbstata Jupyter kernel within a uv virtual environment on macOS, Windows, and Linux; in order to conveniently and reproducibly render Quarto documents using the jupyter: nbstata engine. And I have also shown how to set this up as a Python project.

Running R on Windows on ARM on GitHub Actions

Wed, 16 Apr 2025 00:00:00 +0000

Introduction

GitHub has recently announced that Windows ARM64 runners are now available under the windows-11-arm label.

I help maintain an R package, TwoSampleMR, which has quite alot of users. The package is not on CRAN because several of its dependencies are only on GitHub, and for a package to be on CRAN essentially all of its dependencies must also be on CRAN. As a result I am always interested to try installing the package on new operating systems and architectures.

(In this post I will use ARM and AARCH64 interchangeably.)

Setting up R AARCH64 on Windows on ARM

Avoiding confusion with the default runner software

It is important to mention that the x86_64 version of R 4.4.2 and RTools44 are included in the default software set for the windows-latest GitHub Actions runner. And the directory including its binaries are on the PATH environment variable (specifically C:\Program Files (x86)\R\R-4.4.2\bin\x64). As a result if you run R, Rscript, or R CMD batch etc. in a shell in the runner you will obtain the x86_64 version of R (which runs under emulation on the ARM runner). Let’s say this is not what we want, so to setup the ARM version of R we need to install it ourselves.

Installing AARCH64 R and RTools45

Tomas Kalibera from the R Core Team has provided several excellent posts ( here and here) about R for Windows on ARM, and installers for it have been available for some time.

The r-hub API does not yet provide the installer information for the AARCH64 version of R, so I came up with the following workflow file - amended from r-lib/actions to install R 4.5.0 and RTools45. Place such a (GitHub Actions workflow) file in a public GitHub repo in a .github/workflows directory, and enable GitHub Actions in the repo settings.

on:
  push:
    branches: [main, master]
  pull_request:
    branches: [main, master]
  workflow_dispatch:

name: Check-install-win-11-arm

permissions: read-all

jobs:
  windows-11-on-arm:
    runs-on: windows-11-arm

    name: windows-11-arm

    strategy:
      fail-fast: false

    env:
      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
      R_KEEP_PKG_SOURCE: yes

    steps:
      - name: Install R and RTools for Windows on ARM and install TwoSampleMR
        run: |
          $url = "https://www.r-project.org/nosvn/winutf8/aarch64/R-4-signed/R-4.5.0-aarch64.exe"
          Invoke-WebRequest -Uri "$url" -OutFile R-4.5.0-aarch64.exe -UseBasicParsing -UserAgent "NativeHost"
          Start-Process -FilePath R-4.5.0-aarch64.exe -ArgumentList "/install /norestart /verysilent /SUPPRESSMSGBOXES" -NoNewWindow -Wait
          $url = "https://cran.r-project.org/bin/windows/Rtools/rtools45/files/rtools45-aarch64-6536-6492.exe"
          Invoke-WebRequest -Uri "$url" -OutFile rtools45-aarch64-6536-6492.exe -UseBasicParsing -UserAgent "NativeHost"
          Start-Process -FilePath rtools45-aarch64-6536-6492.exe -ArgumentList "/install /norestart /verysilent /SUPPRESSMSGBOXES" -NoNewWindow -Wait
          $rscript = "C:\Program Files\R-aarch64\R-4.5.0\bin\Rscript.exe"
          $arguments = "-e", "print(R.version); # the rest of your R code goes here ..."
          & $rscript $arguments

Breaking down the final steps section of this;

we define the url of the R 4.5.0 aarch64 installer;
we then download the installer using Invoke-WebRequest (note that the default shell in Windows is Powershell);
we then run the installer using Start-Process. I am not sure if I need all of the arguments I have specified here but it seems to work.
We then do the same for RTools45.
We then define a variable for the path to the Rscript.exe binary;
we define a variable containing the arguments we want to pass to Rscript;
we then invoke Rscript using our two variables and the & call operator.

Then we navigate to our GitHub repo and view the output in the Actions tab under the relevant run.

Of course if you want to run your own R script you’ll need an initial step to checkout your repo.

To confirm that we really have launched the AARCH64 version of R we see the output of print(R.version) is as follows.

print(R.version)
#>                _                           
#> platform       aarch64-w64-mingw32              
#> arch           aarch64                          
#> os             mingw32                          
#> crt            ucrt                             
#> system         aarch64, mingw32                 
#> status                                          
#> major          4                                
#> minor          5.0                              
#> year           2025                             
#> month          04                               
#> day            11                               
#> svn rev        88135                            
#> language       R                                
#> version.string R version 4.5.0 (2025-04-11 ucrt)
#> nickname       How About a Twenty-Six

Summary

I have shown how to install the AARCH64 version of R and RTools45 on the recently released Windows on ARM runner in GitHub Actions.

As an aside, I note that we are now in the interesting position in that GitHub Actions now has Windows, macOS, and Ubuntu Linux all available on both x86_64 and ARM architectures.

Amending the Git commit message of a previous commit (that isn't the most recent) in GitHub Desktop without performing an interactive rebase

Sat, 08 Mar 2025 00:00:00 +0000

Introduction

As R developers I think we can all agree that Git is hard. There won’t be many of us who at some time haven’t broken a Git repository in some way or other or lost some work, I know that I have (several times … ahem).

A task I sometimes need to achieve when working on a branch is amending a commit message. I use GitHub Desktop to help me with Git, and I recommend it to all my students. If the commit you want to amend the message of is the most recent commit you can simply right click on it and select Amend Commit….

This is providing a user friendly interface to running

git commit --amend

in the terminal for us. This is all covered in the GitHub documentation.

However, what if the commit is not the most recent – when you right click those commits the option to amend them is not available. If your commits after your target commit don’t touch the same lines in the same file/s you could reorder your commits such that your target commit is the most recent and then right click and Amend Commit… again.

What if you can’t easily or don’t want to reorder your commits? At this point you might start questioning your life choices; how did I end up using the same tools as the Linux kernel developers? All I want to do is amend a commit message! Anyway, the proper answer is to perform an interactive rebase, but that is relatively advanced and not without stress. Luckily I have a simple trick in GitHub Desktop to achieve our goal without performing an interactive rebase.

The trick: squashing an empty commit onto the target commit

GitHub Desktop allows us to squash to commits together. When it does this it allows us to amend the commit message of the resulting commit. Therefore, to achieve our goal of amending previous commit messages we need to:

Identify the commit you want to amend the message of. Here I have made a typo and want to fix the message to say Use test-rcpp.R

Create an empty commit

For this you will need command line Git installed (GitHub Desktop has a version of Git bundled within it, so not everyone who has GitHub Desktop installed has Git installed separately). Run the following (you don’t have to include the message).
```
git commit --allow-empty -m "Empty commit for purposes of trick"
```
Perform a squash in GitHub Desktop by dragging and dropping the empty commit onto your target commit as per the screenshot below (and in the screenshot at the top of this post). The empty commit has no content, so it does not affect the content of your target commit.

Enter your amended commit message in the Summary box and delete the text in the Description box.

Click Squash 2 Commits.

That’s it, we’re finished! You can now push your branch upto GitHub (or in my case in the screenshot force push because I had previously pushed this branch to the remote).

The proper method: performing an interactive rebase

If you want to do achieve this the proper way or amend the contents of previous commits you’ll need to perform an interactive rebase. That is a little bit tricky to perform in the terminal, although there are lots of helpful YouTube videos and blogposts showing how to do it.

If you ever need to do this I recommend using the Lazygit terminal user interface, which has the best interface to interactive rebasing I’ve seen. To start the process, navigate to the Reflog pane (by pressing Tab twice), then use your up and down arrows to select your target commit, and either press r to reword (i.e., amend the commit message) or e to edit the commit itself (or choose one of the other options listed at the bottom).

Summary

I have shown how to amend commit messages for commits that aren’t the most recent commit in GitHub Desktop without performing an interactive rebase.

Checking your R packages and practicals on a schedule using GitHub Actions

Mon, 24 Feb 2025 00:00:00 +0000

Introduction

Do you have a R package that’s just on GitHub? How often do you check it? CRAN follows a rolling release model, so any day one of your package’s dependency packages could be updated - breaking your package!

Or maybe you teach a course that runs once a year and it has some R practical sessions? It can be very frustrating when you rerun your practical after a year to find that several of the R packages it uses have been updated, and now you have to work out how to fix things. For this situation we might use renv to record the packages and their versions. But then your course participants will need to use renv which might lead to a room full of 30 students all having renv problems. Alternatively, you might install all your packages from a single date, meaning you can restore them using the a snapshot date from the Public Posit Package Manager but you might find your course participants wondering why you use packages that are a year out of date. Another superb solution is to provide course participants with an R environment you have defined and tested your practical works in. Such a solution is offered by creating the practical as a project in a Posit Cloud workspace, indeed Posit Cloud is so good it almost makes running R practicals boring.

My solution to these problems is to regularly run R CMD check on your package/run your practical with the latest versions of the required packages throughout the year. This way you’ll hopefully pick up any changes in dependency packages long before the next running of your course (although you might still be unlucky).

If I had a server I could suggest setting up a cron job to check the package or practical. However, most of us don’t have a server. Luckily if your package or practical is in a public GitHub repository then we can run GitHub Actions on it. It turns out GitHub Actions has a scheduling facility that uses cron syntax.

Next I’ll show how to run R code on a schedule on GitHub Actions for these two cases.

Checking packages on a schedule

I use the actions and example workflows from the r-lib/actions repository. For checking a package there are several examples, in the examples directory of that repository, that we can copy then amend. Let’s use the check-full.yaml example.

Copy this file into a .github/workflows directory in the repository for your package. Now we need to enable scheduled running. Amend the first on: block to include the two lines I have inserted below.

on:
  ...
  schedule:
    - cron: "00 9 * * TUE"

What does this syntax mean? Luckily there are many websites which will decipher that for us, such as crontab guru. (Nb. you can see a full version of this file in one of my repositories.)

From the crontab guru screenshot above, we see this means run at 9:00 am (UTC) on Tuesdays. Once you have committed this file to your repo and pushed it to GitHub on your main/master branch then your automated checking is taken care of. If a check fails GitHub will send a notification and you can then investigate further.

Running practicals on a schedule

Let’s say we have prepared a practical worksheet in a Quarto document. In this case we’ll additionally use the actions and examples in the quarto-dev/quarto-actions repository.

The workflow file I ended up with is shown below and is in this example repository. It is essentially an amended version of the R Markdown rendering example in r-lib/actions.

on:
  push:
    branches:
      - main
  workflow_dispatch:
  schedule:
    - cron: "0 0 1 * *" # run on 1st day of month

name: Render

permissions: 
  contents: write

jobs:
  build-deploy:
    runs-on: ${{ matrix.config.os }}
    
    name: ${{ matrix.config.os }}

    strategy:
      fail-fast: false
      max-parallel: 1
      matrix:
        config:
          - { os: macos-latest }
          - { os: windows-latest }
          - { os: ubuntu-latest }
    
    env:
      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
    
    steps:
      - name: Check out repository
        uses: actions/checkout@v4
        
      - name: Setup R
        uses: r-lib/actions/setup-r@v2

      - name: Set up Quarto
        uses: quarto-dev/quarto-actions/setup@v2

      - name: Setup R packages
        uses: r-lib/actions/setup-r-dependencies@v2
        with:
          upgrade: 'TRUE'

      - name: Render practical and commit output documents into repo
        shell: bash
        run: |
          # Render questions
          Rscript -e 'quarto::quarto_render("exercise-01.qmd", output_file = "exercise-01-questions-${{ matrix.config.os }}.html", execute_params = list(solutions = FALSE, title = "Example exercise: Questions"))'
          # Render solutions
          Rscript -e 'quarto::quarto_render("exercise-01.qmd", output_file = "exercise-01-solutions-${{ matrix.config.os }}.html")'
          # Commit output documents
          git config --local user.name $GITHUB_ACTOR
          git config --local user.email [email protected]
          git pull
          git add "*.html"
          git commit * -m "Render practical on ${{ matrix.config.os }}" || echo 'No changes to commit'
          git push origin || echo 'No changes to commit'

Crikey, that’s alot, let’s break that down.

The on: section defines this will run
- on pushes to the main branch,
- if the workflow dispatch button is clicked in the GitHub interface,
- and once per month (at midnight on the first day on the month) as defined by our cron syntax
The jobs: section specifies
- we will run this on 3 different operating systems, Windows (most of my students/course participants have Windows laptops, followed by macOS), macOS, and Ubuntu Linux. More info about GitHub Actions runners is available;
- max-parallel: 1 says that each job will run in turn (this isn’t really needed but just to be safe since I will commit the output documents back into the repository)
- env: specifies that we grant the jobs permission with out GitHub token
- steps: defines what will run, which is
  - we checkout the repo
  - we then install R and Quarto using the relevant actions
  - we setup the R dependency packages. I am not using renv, so the action knows how to do this because I have included a DESCRIPTION file in the repo (to the action we are faking that the repo is an R package - this is a trick from Hadley Wickham). The full file is in the repository but the key entry is the Imports list of hard depdenency packages.
```
...
Imports:
    knitr,
    quarto,
    sessioninfo
...
```
- we specify upgrade: 'TRUE' to always install the latest version of the dependency packages.
- then we finally render the two versions of our Quarto document. Here we append the operating system name into the output document filenames and we commit these files back into the repository for our records. We have to specify shell: bash because otherwise the Windows runner will use Powershell and the environment variable syntax in the git config commands would be incorrect. Also we need a git pull before making the commit because we have 3 jobs running in series, so there will be new/amended files in the repo after the first and second jobs.

Phew!

It’s worth pointing out that instead of a Quarto document our practical could be in an R Markdown document or an R script (we’d just need to make the relevant changes in the workflow file above such as adding Pandoc and amending the render commands).

Note, GitHub Actions only works for free in a public repository; so obviously this can’t be used for any material that is assessed.

Surprise benefits

A nice side effect of using the r-lib/actions/setup-r and quarto-dev/quarto-actions/setup actions is that they update to the release version of R/Quarto as updates are released. So you don’t have to worry about updating the version of R/Quarto.

GitHub Actions woes

At this point I acknowledge that sometimes GitHub Actions can be more trouble than they are worth. This is because they often fail for reasons which are not problems with your code. For example, I had one repository in which the Windows runner would regularly lose internet connection (I have no idea why) half way through installing the R dependency packages and hence would regularly notify me of a failed check. Also you need to keep the code in your workflow file up-to-date. Usually a quick comparison to the current version of the example in the r-lib/actions repo is enough to show you what you need to change.

Summary

I have shown how to use GitHub Actions scheduling feature to automatically run scheduled checks on R packages and R scripts/R Markdown/Quarto documents for practicals enabling you to keep on top of any changes in your dependency packages and indeed in any changes in the release versions of R and Quarto.

Creating a Finder Smart Folder of your RStudio Project files to enable super fast project launching

Fri, 21 Feb 2025 00:00:00 +0000

Introduction

When I’m switching projects I naturally start with Finder. I’m sure if I became a Terminal warrior there are faster ways of searching for files (e.g. the Television fuzzy finder TUI). And I know there are other ways to avoid using Finder, e.g., using Spotlight, Alfred, or Raycast; and indeed I do have this fantastic tip that allows Alfred to find RStudio project files setup. But something to do with how I learnt to use a computer just naturally means I’m wedded to Finder, but navigating through my mess of nested directories wastes time and energy.

I realised that Finder on macOS has a helpful feature called Smart Folders. We can use this to setup a saved search of RStudio Project .Rproj files (and/or VSCode/Positron .code-workspace files) to allow us to see all the .Rproj files on our computer. This makes finding and opening projects from within Finder fast and convenient.

Setting up a Smart Folder of your RStudio project files

In Finder;

navigate to the folder you want your search to start in, either your home folder or your Documents folder are obvious candidates
click File | New Smart Folder

near the top right corner click the plus button next to the Save button.

we need to add the File extension attribute to the choices, click Name near the top left, then Other…

Then search for File extension and check the box on the right handside

enter Rproj in the box (it doesn’t seem to matter if you include the . first)

click Save (near top right corner) and give it a sensible name, e.g., Rproj.savedSearch

And you’ll see the new virtual folder appear on the left Finder sidebar - see the screenshot at the top of this post.

You can create additional Smart Folders for other useful file extensions, for example, VSCode/Positron project files (.code-workspace files).

On Windows, I don’t believe that there is an exact equivalent of a Smart Folder. I think that the closest you can get is to save a search in File Explorer. However, I find that in recent years File Explorer on Windows 11 has become incredibly slow and regularly crashes. Searching in Files or File Pilot is now much faster and more reliable.

Summary

I have shown how to create a Smart Folder of your RStudio Project files for fast and convenient project launching on macOS.

Creating R, Python, Stata, and Julia tutorial worksheets (with and without solutions) using Quarto

Tue, 18 Feb 2025 00:00:00 +0000

Introduction

I regularly need to produce exercises/tutorials for my students. One fantastic feature of R Markdown is that it allows me to create one R Markdown document which can be rendered to both the question document and the solutions document. This is achieved by toggling knitr chunk options such as eval, echo, and include, and using asis chunks to include the text for the solutions. I wrote a little package, knitexercise to help with this.

The toggling of the knitr chunk options can be parameterised making it possible to have an R script which contains the code to conveniently produce both questions and solutions documents. An example R Markdown file, exercise.Rmd, might look like the following.

---
title: "`r params$title`"
output: html_document
params:
  solutions: TRUE
  title: "Example exercise: Solutions"
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(include = params$solutions)
```

1. This is question 1. Which might have some R code you always want to show.

   ```{r, include=TRUE}
   # example code for the question
   ```

   ```{asis}
   Paragraph text for the solution can be kept in the document in an `asis` chunk.
   And solution R code in an `r` chunk.
   Both of these will use the `include` value from the `setup` chunk.
   ```
    
   ```{r}
   # example code for the solution
   ```

2. This is question 2 ...

And the rendering script might look like this.

rmarkdown::render("exercise.Rmd",
  output_file = "exercise-questions",
  params = list(solutions = FALSE, title = "Example exercise: Questions")
)

rmarkdown::render("exercise.Rmd",
  output_file = "exercise-solutions"
)

Inline code

Inline code has been a feature of R Markdown for a while. Yihui Xie and Christophe Dervieux have used it to pull off some fantastic tricks. My favourite trick is using it to programmatically write out R Markdown/Markdown code within an R Markdown document when a certain condition is met.

`r if (knitr::is_latex_output()) "...some_Markdown_to_include_when_rendering_to_pdf..."`

The problem

R Markdown is incredibly flexible because we can include R objects as document and chunk options. When translating this to a pure Quarto version we can do this in a document using in the knitr engine using the ! expr ... YAML tag literal. As far as I am aware, this is not yet possible for any other Quarto engine. Despite this my aim was to see whether I could achieve parameterised conditional content inclusion/exclusion in a Quarto document using other engines.

Programmatically including conditional content in Quarto documents

The code described below is presented in the following demo repo, and the rendered output files can also be viewed.

R: knitr and Quarto

I have already shown the R Markdown approach above.

For Quarto using the knitr engine, in a blog post Nicola Rennie used inline code to write out Quarto’s conditional content classes.

---
format: html
params:
  hide_answers: true
engine: knitr
---

`r if (params$hide_answers) "::: {.content-hidden}"`

Text and code for answers.

`r if (params$hide_answers) ":::"`

Note that if you use the curly braces around the r to write you inline code then you need to enclose the output string in the I() function and include the else statement as follows.

`{r} if (params$hide_answers) I("::: {.content-hidden}") else ""`

Then we can have a shell script to render our questions and solutions documents as follows.

quarto render exercise-r.qmd -o exercise-r-questions.html
quarto render exercise-r.qmd -P hide_answers:false -o exercise-r-solutions.html

Python

I realised I could adapt Nicola Rennie’s approach for other engines. For the jupyter: python3 engine we can do so as follows, the following code uses Quarto’s parameters feature.

---
format: html
jupyter: python3
---

```{python}
#| include: false
#| tags: [parameters]
hide_answers = True
```

```{python}
#| include: false
from IPython.display import Markdown
```

`{python} Markdown("::: {.content-hidden}") if hide_answers else Markdown(" ")`

```{python}
print("Hidden in questions")
```

`{python} Markdown(":::") if hide_answers else Markdown(" ")`

The shell script to render our questions and solutions documents is as follows.

quarto render exercise-python.qmd -o exercise-python-questions.html
quarto render exercise-python.qmd -P hide_answers:False -o exercise-python-solutions.html

As of Quarto version 1.7.23 it is possible to suppress the injected parameters cell.

Stata

The Stata case involved two additional tricks. First, the nbstata Jupyter kernel allows inline code, however this must be a display command, so we cannot write the if statement within the inline code. I found I can overcome this by saving the different strings in scalars (because the inline code can’t use local macros) at the top of the document as follows. Second, I didn’t try but I suspect the nbstata kernel doesn’t support parameters, and so I achieved the toggling of the code using an environment variable, e.g. HIDE_ANSWERS_STATA.

---
format: html
jupyter: nbstata
---

```{stata}
*| include: false
local hide_answers : env HIDE_ANSWERS_STATA
if (`hide_answers') {
    scalar hide_answers_open = "::: {.content-hidden}"
    scalar hide_answers_close = ":::"     
}
else {
    scalar hide_answers_open = " "
    scalar hide_answers_close = " "
}
```

`{stata} scalar(hide_answers_open)`

```{stata}
display "Hidden in questions"
```

`{stata} scalar(hide_answers_close)`

The shell script to render the documents is then as follows, here we define the environment variable before the call to quarto.

HIDE_ANSWERS_STATA=1 quarto render exercise-stata.qmd -o exercise-stata-questions.html
HIDE_ANSWERS_STATA=0 quarto render exercise-stata.qmd -o exercise-stata-solutions.html

Julia

For the native Julia engine I found that Quarto’s parameterisation worked and that I didn’t require a code chunk with a parameters tag.

---
format: html
engine: julia
---

```{julia}
#| include: false
using Markdown
```

`{julia} hide_answers ? md"::: {.content-hidden}" : md""`

```{julia}
println("Hidden in questions")
```

`{julia} hide_answers ? md":::" : md""`

The shell script to render the documents is then as follows.

quarto render exercise-julia.qmd -P hide_answers:true -o exercise-julia-questions.html
quarto render exercise-julia.qmd -P hide_answers:false -o exercise-julia-solutions.html

Problems with environment variables

I found that passing environment variables, to the jupyter: python3 and engine: julia is unreliable/broken. Admittedly, I was not using Quarto in project mode with an _environment file, but honestly it doesn’t feel to me I should need to do that for a single document.

The problem I found was that after a first render the value of the environment variable seems to be cached within the Quarto output document and I couldn’t change it on subsequent renders. I also found that using the dotenv package to access was broken in the same way.

For engine: julia I also found that passing environment variables is unreliable and like for the jupyter: python3 engine I experienced environment variable values being stuck after the first render. However, using the Julia DotEnv package did seem to be reliable.

Summary

I have shown how to programmatically include conditional content for several Quarto engines (knitr, jupyter: python3, jupyter: nbstata, and engine: julia) using parameters or environment variables to toggle inline code to write Quarto Markdown in the Quarto documents. I use this to write exercise/tutorial documents in which a single Quarto document is used to output both the questions and solutions documents.

Creating effectively multi-engine Quarto documents using Quarto's embed shortcode

Sat, 15 Feb 2025 00:00:00 +0000

Introduction

Have you ever needed to present the code and output for several languages in the same document or website? I work in (non-infectious disease) Epidemiology and so it is common that researchers would like to present R and Stata code in the same document. However, a Quarto document can only run a single engine. There are already several work around solutions, which include:

writing out the different language code cells but making them unevaluated/not executed chunks (this is done alot on the Quarto documentation website). One can also include saved plots from the different languages;
if your document has a combination of languages from which you can call one from the other, such as using reticulate from within R to run Python, or using Statamarkdown from within R to run Stata, or using JuliaCall from within R to run Julia, then these can be combined in a Quarto document;
or for some languages like R and Python we could even embed full WebAssembly implementations of the language ( WebR and Pyodide respectively) within a webpage (which admittedly seems a little overkill for my work).

I’ve found an alternative solution allowing you to use the native engines for each language. I recently stumbled across Quarto’s embed shortcode. This allows another (or selected cells from another) Quarto document to be embedded in a Quarto document. A thought occurred to me, what if the embedded Quarto document/s used a different engine? Would that work? This isn’t explicitly mentioned on the documentation page, so I gave it a go. Remarkably, the answer turns out to be that it works! Let’s find out what to do.

Using the embed shortcode to create an effectively multi-engine Quarto document

In the example below I’m using a tabset in a html document using the knitr engine. We embed the documents using the alternative engines for Python, Stata, and Julia using the {{< embed >}} shortcode as shown below. For each language I just show printing a string and a basic plot.

---
title: An effectively multi-engine Quarto document using the embed shortcode
format:
  html:
    embed-resources: true
engine: knitr
---

::: {.panel-tabset .nav-pills}
## R

```{r}
print("Hello World, from R")
```

```{r}
#| fig-align: "center"
x <- seq(-10,10, by = 0.1)
y <- x ^ 3
plot(x, y, type = "l")
```

## Python

{{< embed python-code-using-jupyter-python3-engine.qmd echo=true >}}

## Stata

{{< embed stata-code-using-jupyter-nbstata-engine.qmd echo=true >}}

## Julia

{{< embed julia-code-using-julia-engine.qmd echo=true >}}

:::

the python-code-using-jupyter-python3-engine.qmd document uses the jupyter: python3 engine ( documentation for using Python in Quarto);
the stata-code-using-jupyter-nbstata-engine.qmd document uses the jupyter: nbstata engine ( documentation for nbstata);
and the julia-code-using-julia-engine.qmd uses engine: julia. Alternatively, it should be possible to use the IJulia Jupyter kernel ( documentation for using Julia in Quarto)

Of course, I assume that you have setup each engine beforehand.

Rendering the Quarto document above results in the embedded documents being executed and embedded within it. I’ve included the output below (and the full source code is in this repository). Click the tabs to show the code and output for each language.

In the code above, in each case, I embed the whole Quarto document but you can also specify a specific code block id (or if the embedded document is a Jupyter Notebook, .ipynb file, you can specify a cell id, label, or tag).

Summary

I have shown how to use the Quarto embed shortcode to embed Quarto documents using alternative engines to create an effectively multi-engine Quarto document.

Seven tips for creating Quarto revealjs presentations

Sun, 19 Jan 2025 00:00:00 +0000

Introduction

Like a lot of lecturers I’m teaching at the moment. If I have a presentation to do that’s mainly images I’ll use Powerpoint or Google Slides. If the presentation includes maths or code or both I used to use LaTeX Beamer. Over the years I have grown tired of Beamer and so I thought I’d try making some revealjs presentations using Quarto.

Revealjs has been around far longer than Quarto, I remember seeing a colleague present using revealjs in about 2012, and you can happily make a revealjs presentation without Quarto. However, the convenience of writing in the Quarto Markdown format is fantastic.

To learn the basics of making revealjs slides with Quarto I recommend reading the user guide. And full documentation is available here and here.

The following tips are solutions to little hurdles that I found I needed to overcome when making my first revealjs presentations using Quarto.

1. Slide size and testing on a smaller display size on your own monitor

The great thing about making a presentation in Powerpoint or Google Slides is that you can instantly see if your content fits on a slide. So it helps to have an understanding of how big a slide is. By default a revealjs slide is 1050px wide by 700px tall. This helps you when setting the size of figures and code blocks.

Additionally it is helpful to be able to preview your slides on the size on monitor you will be presenting on. My University has 1080p monitors in most lecture theatres, however, my monitor is bigger than that. Chrome allows setting the size of the display by opening Developer Tools (Three dots | More tools | Developer Tools). Then you can enter the desired resolution in the top bar as follows (a 1080p screen is 1080 pixels tall and 1920 pixels wide).

I find this especially helpful when working on a Mac, whose laptops often have unusual screen resolutions.

2. Wider width cutoff in code chunks

Vertical space on a slide is at a premium. Therefore, in a presentation I line break my code wider that I do when coding normally. As described in the RMarkdown cookbook and in this GitHub issue we can enable the use of the formatR package on a code chunk using the tidy and tidy-opts chunk options (I think the default is 85 characters, so I choose a value greater than that. I find that 110 is about the widest I can set).

```{r}
#| tidy: TRUE
#| tidy-opts: !expr list(width.cutoff = I(110))
# ... Wide R code here ...
```

We can also set these globally for the Quarto document in either the YAML header,

knitr:
  opts_chunk: 
    tidy: TRUE
    tidy-opts: !expr list(width.cutoff = I(110))

or in a chunk at the top of your Quarto document.

```{r}
#| include: false
knitr::opts_chunk$set(tidy = TRUE, tidy.opts = list(width.cutoff = I(110)))
```

3. Taller code chunks

Code chunks come in several flavours in a rendered presentation. There are code input chunks, code output chunks, and chunks for any code output errors. To make the input code chunks taller there is a convenient Quarto option code-block-height which is specified in the YAML header (the default is 500px, so pick a value greater than that).

---
format:
  revealjs:
    code-block-height: 650px
---

4. Taller code output chunks

Currently, there doesn’t seem to be a Quarto option to make the code output chunks taller. Therefore I had to inspect the source code of the html slides to find out how to modify this. In most browsers simply right click on a slide and in Chrome click Inspect - do this over the element on the page you want to find out about.

Doing so over a code output cell shows the developer tools on the right handside. We can then see that the elements and classes for the code output cell are given just above the bottom right pane, i.e., div.cell div.cell-output.cell-output-stdout pre code.

Therefore, we can make the code output cell have a taller maximum height by specifying max-height as follows in a CSS file which we reference in the YAML header. Note that the default is 400px, so choose a value larger than that.

---
format:
  revealjs:
    css: custom.css
---

The contents of custom.css use the elements and classes of the code chunk we discovered as follows.

.cell .cell-output-stdout pre code {
  max-height: 650px; // Adjust this value as needed
  overflow-y: auto; // Add this to handle overflow
}

5. Embedding interactive Mentimeter presentations

Mentimeter provides the html code required to embed a presentation within an html document. To obtain this, go into a presentation and click the Share button, then select the Slides tab, then click Copy code under Embed slides.

This results in a div containing an iframe, which we can simply paste in as the content of our slide (I have added the line breaks and replaced part of the URL to my presentation with hashes).

## My slide with an embedded Menti

<div style='position: relative; padding-bottom: 56.25%; padding-top: 35px;
  height: 0; overflow: hidden;'>
<iframe sandbox='allow-scripts allow-same-origin allow-presentation'
  allowfullscreen='true' allowtransparency='true' frameborder='0' height='315'
  src='https://www.mentimeter.com/app/presentation/###############/embed'
  style='position: absolute; top: 0; left: 0; width: 100%; height: 100%;'
  width='420'>
</iframe>
</div>

But when I first rendered a presentation using this code I didn’t see my Mentimeter presentation in the relevant slide but rather the following spinning dots.

Thanks to this post it turns out this is because I had specified embed-resources: true in my revealjs options in the YAML header. When you do this you need to add the data-external="1" attribute to the iframe as detailed in the Quarto documentation as follows.

<iframe data-external="1" sandbox=...

And then my Mentimeter presentation was correctly embedded in the slide as per the screenshot at the top of this post.

6. Disable HTML table processing for some tables

There are now so many fantastic R packages for html table generation. My two favourite are gtsummary and sjPlot. However, I notice that for some sjPlot tables Quarto issues the following warning when rendering the slides.

WARNING (/Applications/quarto/share/filters/main.lua:9319) Unable to parse table from raw html block: skipping.

To avoid this it’s possible to disable Quarto’s html table processing using the html-table-processing argument either at the document or chunk level. Here is an example slide doing so at the chunk level.

## Slide presenting a multilevel model

```{r}
#| html-table-processing: none
library(sjPlot)
library(lme4)
fm1 <- lmer(Reaction ~ Days + (Days | Subject), sleepstudy)
tab_model(fm1)
```

7. Programmatic rendering and pdf export for printing

To render a Quarto document we can click the Render button in RStudio, but I find it easier to make a render.R script with a call to the quarto package’s quarto_render() function.

It’s helpful to provide students with a pdf copy of the slides for printing. You can do this in a browser through the print menu or programmatically using pagedown’s chrome_print() function. When I called this function with no options the page size of the pdf was unusual, producing pages with neither A4 nor US paper size, so I call it as follows to ensure an A4 page size.

Therefore, my render.R script often looks something like the following.

quarto::quarto_render(input = "my-great-slides.qmd")

pagedown::chrome_print("my-great-slides.html", 
  options = 
    list(
      printBackground = FALSE,
      preferCSSPageSize = FALSE, 
      paperWidth = 8.3, paperHeight = 11.7, 
      marginTop = 0.1, marginBottom = 0.1, 
      marginLeft = 0.1, marginRight = 0.1))

I usually find that a few slides have slightly too much content for an A4 page, and so those slides will take up 2 pages in the pdf. And hence the pdf usually has a few more pages than the number of slides.

Summary

I have shown seven tips that I needed to workout when making revealjs presentations with Quarto.

My #GitHubUnwrapped 2024!

Wed, 08 Jan 2025 00:00:00 +0000

My #GitHubUnwrapped 2024!

Made with https://www.githubunwrapped.com/.

Launch RStudio, Positron, and other Data Science apps from your Finder Toolbar

Mon, 23 Dec 2024 00:00:00 +0000

Introduction

Have you ever wanted to be able to quickly open a Data Science app, say RStudio Desktop or Positron in the current Finder window at the click of a button? We’ll see how to achieve this by creating Automator apps. Here’s a screenshot of what we’ll end up with.

Creating the Automator apps

Open Automator and select New then Application and click Choose. Then in the top left search bar enter applescript and drag and drop the Run Applescript action onto the main window.

We then need to enter the relevant AppleScript code for launching each app in the current Finder window. Currently, I use WezTerm for my terminal emulator, Zed as my main text editor, RStudio Desktop for most of my R/R Markdown/Quarto coding, Visual Studio Code for other text editing tasks, and I have been starting to try out Positron. My AppleScript code for each app is as follows.

RStudio Desktop

It is worth noting that RStudio automatically detects whether there is an .Rproj file in the directory and opens in project mode if one is found (note this only works if RStudio is not already open).

on run {input, parameters}
  tell application "Finder"
    set myWin to window 1
    set thePath to (quoted form of POSIX path of (target of myWin as alias))
    do shell script "/Applications/RStudio.app/Contents/MacOS/RStudio " & thePath
  end tell
end run

We can create an alternative app which specifically opens RStudio project (.Rproj) files as follows.

on run {input, parameters}
  tell application "Finder"
    try
      set currentFolder to (folder of window 1) as alias
      set workspaceFiles to (every file of currentFolder whose name extension is "Rproj")
      if (count of workspaceFiles) = 0 then
        set thePath to quoted form of POSIX path of (currentFolder as alias)
        do shell script "/Applications/RStudio.app/Contents/MacOS/RStudio " & thePath
      else if (count of workspaceFiles) = 1 then 
        set workspaceFile to item 1 of workspaceFiles
        set workspacePath to POSIX path of (workspaceFile as alias)
        do shell script "open -n -a RStudio " & quoted form of workspacePath
      else if (count of workspaceFiles) > 1 then 
        display dialog "Multiple Rproj files found in directory."
      end if
      on error
        display dialog "No Finder window is open."
      end try
  end tell
end run

WezTerm

on run {input, parameters}
  tell application "Finder"
    set myWin to window 1
    set thePath to (quoted form of POSIX path of (target of myWin as alias))
    do shell script "/opt/homebrew/bin/wezterm-gui start --cwd " & thePath & "&> /dev/null &"
  end tell
end run

Zed

on run {input, parameters}
  tell application "Finder"
    set myWin to window 1
    set thePath to (quoted form of POSIX path of (target of myWin as alias))
    do shell script "/usr/local/bin/zed -n " & thePath
  end tell
end run

R launched in a WezTerm terminal session

on run {input, parameters}
  tell application "Finder"
    set myWin to window 1
    set thePath to (quoted form of POSIX path of (target of myWin as alias))
    do shell script "/opt/homebrew/bin/wezterm-gui start --cwd " & thePath & " -- /usr/local/bin/R &> /dev/null &"
  end tell
end run

Visual Studio Code and Positron

First enable the ability to launch these apps with code and positron from a Terminal in each app, see here and here.

This script is more involved because we first check for any .code-workspace files and open one if found. My AppleScript coding is not very proficient, so there may more efficient approaches to coding this. If we didn’t explicitly open the .code-workspace file and if one is present in the directory Visual Studio Code/Positron will detect it and pop up a dialogue box asking if we want to reopen the directory as a workspace (I just prefer to skip this step).

on run {input, parameters}
  tell application "Finder"
    try
      set currentFolder to (folder of window 1) as alias
      set workspaceFiles to (every file of currentFolder whose name extension is "code-workspace")
      if (count of workspaceFiles) = 0 then 
        set folderPath to POSIX path of currentFolder
        do shell script "/usr/local/bin/positron -n " & quoted form of folderPath
      else if (count of workspaceFiles) = 1 then 
        set workspaceFile to item 1 of workspaceFiles
        set workspacePath to POSIX path of (workspaceFile as alias)
        do shell script "/usr/local/bin/positron -n " & quoted form of workspacePath
      else if (count of workspaceFiles) > 1 then 
        display dialog "Multiple code-workspace files found in directory."  
      end if
      on error
        display dialog "No Finder window is open."
      end try
  end tell
end run

(For your Visual Studio Code app simply replace positron with code.)

Ghostty

on run {input, parameters}
  tell application "Finder"
    set myWin to window 1
    set thePath to (quoted form of POSIX path of (target of myWin as alias))
    do shell script "open -na ghostty --args --title=ghostty-from-finder --working-directory=" & thePath
  end tell
end run

Saving and adding icons

After adding the AppleScript code save each app. I call mine, e.g., RStudio-openhere.app.

Next it is helpful to give each app the relevant icon. To do this in Finder bring up the Info boxes for the original app and your -openhere version by selecting each app and pressing Cmd+I. Next drag the large icon from the original app onto the small icon of your -openhere app.

Finally, we need to place shortcuts of these apps onto the Finder toolbar. To do this first hold down Cmd then drag the app from Finder onto the toolbar to the location you would like. On release the app should now be in the toolbar. (And to remove an icon from the toolbar, again hold Cmd then drag it off the toolbar.)

Summary

I have shown how to create Automator apps to open RStudio Desktop, Positron, and several other Data Science apps from the current Finder window.

The MRC IEU R-Universe of Mendelian randomization related R packages 🚀

Wed, 19 Jun 2024 16:45:00 +0000

Supercharge your #rstats web searching in Google Chrome with Site Search Shortcuts

Fri, 14 Jun 2024 00:00:00 +0000

Introduction

Have you ever typed Amazon into the Google Chrome address bar and seen the address bar indicate that it’s now searching the Amazon site? It turns out this is a feature in Google Chrome called site search shortcuts.

We can see what default shortcuts Chrome provides by in the Chrome address bar going to chrome://settings/searchEngines and scrolling to the Site Search section.

From here we can see that we can define our own shortcuts, so let’s define some helpful ones related to R and statistics.¹

Helpful Google Chrome site search shortcuts for R and statistics

METACRAN provides several amazingly useful services around CRAN.

A shortcut for searching the METACRAN CRAN mirror on GitHub

Name: CRAN mirror on GitHub
Shortcut: @cran
URL with %s in place of query:
https://github.com/search?q=user%3Acran%20%s&ref=opensearch&type=code

On the Chrome settings page click add and enter the information. To use this simply type @cran into the address bar

and then type your search term

Here are some other shortcuts.

A shortcut for searching for a package description on METACRAN

Name: METACRAN
Shortcut: @metacran
URL with %s in place of query:
https://r-pkg.org/search.html/?q=%s

A shortcut for searching using Rseek

Name: Rseek
Shortcut: @rseek
URL with %s in place of query:
https://rseek.org/?q=%s

A shortcut for searching R-universe

Name: R-universe
Shortcut: @runi
URL with %s in place of query:
https://r-universe.dev/search/?q=%s

A shortcut for searching the third edition of the Oxford Dictionary of Statistics

Name: Oxford Dictionary of Statistics
Shortcut: @stats
URL with %s in place of query:
https://www.oxfordreference.com/search?source=%2F10.1093%2Facref%2F9780199679188.001.0001%2Facref-9780199679188&q=%s

And we could define many more.

Summary

In summary we have defined several Google Chrome site search shortcuts related to R and statistics.

I am following an excellent blogpost by Chrome Unboxed. ↩︎

Running MLwiN using mlnscript via the R2MLwiN R package on Apple Silicon Macs

Tue, 02 Apr 2024 00:00:00 +0000

Introduction

MLwiN from the Centre for Multilevel Modelling (CMM) at the University of Bristol (disclaimer: where I also work) is a fantastic piece of software ( Charlton et al. 2024). The name suggests it only works on Windows, but as we’ll find out this is very much not the case.

However, in the past this was sort of true because to make it work on a Mac (or Linux machine) with an Intel processor one would need to run it using Wine.

More recently, CMM have cleverly made the MLwiN libraries available for other operating systems in a command line version of the program called mlnscript and an accompanying library. The files for macOS are universal binaries which means that they run natively on both Intel and Apple Silicon Macs. Let’s find out how to set this up.¹

Setting up mlnscript on an Apple Silicon Mac

Obtain the installer for macOS. See the relevant download page (depending upon whether you are an academic) on the MLwiN website. On the form on the File to download dropdown menu select the mlnscript for MacOS option. This will give you the MLN.dmg installer.
Double click the installer. On macOS it is recommended to install the files into the /opt/mln/ directory, which you will need to create with Admin permissions, or install to another directory if you don’t have Admin permissions. Copy the 2 files mlnscript and libmln.dylib into the /opt/mln (or other) directory.
Once installed we can check that mlnscript and libmln.dylib are universal binaries as follows (we could also use the file command).
```
lipo -archs /opt/mln/mlnscript
## x86_64 arm64
```
Since both architectures are listed in the output this indicates the files are universal binaries. Apple Silicon Macs will use the arm64 architecture.
Now we need to grant the two files permission to run. To do this run the following in your Terminal.
```
/opt/mln/mlnscript --version
```
On first run, this will fail with a pop-up similar to the following.

Click Cancel and then go into the System settings | Privacy & Security and scroll down and click Allow Anyway.

Then running the version check command again you may receive another popup in which you click Open.

After this the first popup will then appear but about the libmln.dylib file. Again set the security setting to Allow All.

Now running the version check command again you should see the version number – which is currently 3.10.

/opt/mln/mlnscript --version
## 3.13

In R we then install the R2MLwiN package from CRAN ( Zhang et al. 2016).
```
install.packages("R2MLwiN")
```

This completes the setup - phew 😮!

Running a multilevel model

For an example we could run one of the demos in the package, we can list those with the following code.

demo(package = "R2MLwiN")

We can run one, for example, let’s fit the random intercept model from the UserGuide02 demo.

library(R2MLwiN)
# if you did not install mlnscript and libmln.dylib in /opt/mln , set:
# options(MLwiN_path = "/path-to/mlnscript")
(mymodel1 <- runMLwiN(normexam ~ 1 + sex + (1 | student), data = tutorial))
#> 
#> -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- 
#> MLwiN (version: unknown or >3.09)  multilevel model (Normal) 
#> Estimation algorithm:  IGLS        Elapsed time : 0.03s 
#> Number of obs:  4059 (from total 4059)        The model converged after 3 iterations.
#> Log likelihood:      -5727.9 
#> Deviance statistic:  11455.7 
#> --------------------------------------------------------------------------------------------------- 
#> The model formula:
#> normexam ~ 1 + sex + (1 | student)
#> Level 1: student      
#> --------------------------------------------------------------------------------------------------- 
#> The fixed part estimates:  
#>                Coef.   Std. Err.       z    Pr(>|z|)         [95% Conf.   Interval] 
#> Intercept   -0.14035     0.02463   -5.70   1.209e-08   ***     -0.18862    -0.09208 
#> sexgirl      0.23367     0.03179    7.35   1.985e-13   ***      0.17136     0.29598 
#> Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1  
#> --------------------------------------------------------------------------------------------------- 
#> The random part estimates at the student level: 
#>                   Coef.   Std. Err. 
#> var_Intercept   0.98454     0.02185 
#> -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-

We can see the output is in several sections. The first section tells us about how mlnscript, which estimation algorithm it used, how long it took to fit the model, and some characteristics of the dataset. The second section tells us about the model, in this case a random intercept model. The third section is the fixed effect estimates and the associated statistical inference for them. The fourth section is the random effect variance estimates.

And we can continue with our multilevel modelling as we like.

Summary

Despite having Win in its name, MLwiN is available as a command line program, mlnscript, which is available on operating systems other than Windows (and indeed with other architectures), including macOS for both Intel and Apple Silicon processors and various Linux and Unix distributions (CentOS, Debian, Fedora, FreeBSD, Rocky, and Ubuntu). This is straightforward to use from R via the R2MLwiN package.

References

Charlton, C., J. Rasbash, W. J. Browne, M. Healy, and B. Cameron. 2024. MLwiN Version 3.10. Bristol, UK: Centre for Multilevel Modelling, University of Bristol. https://www.bristol.ac.uk/cmm/software/mlwin/.

Zhang, Z., R. M. A. Parker, C. M. J. Charlton, G. Leckie, and W. J. Browne. 2016. “R2MLwiN: A Package to Run MLwiN from Within R.” Journal of Statistical Software 72 (10): 1–43. https://doi.org/10.18637/jss.v072.i10.

This post is essentially a more detailed explanation of the advice given on the MLwiN website, here and here. ↩︎

Creating a simple Automator app to launch a new instance of RStudio Desktop on macOS

Sun, 31 Mar 2024 00:00:00 +0000

Introduction: how to open a second instance of RStudio Desktop on macOS

On macOS when RStudio Desktop is open it can be inconvenient to open a second (or third or fourth) instance of it.

If you left click the RStudio Desktop icon nothing happens. If you right click on the RStudio Desktop icon there is a convenient New RStudio Window. The problem with this is that by default if you have an RStudio project open the new RStudio window is also opened in that project. However, that can be overcome by opening the RStudio preference pane and in the first tab (General | Basic) deselecting the boxes relating to Restore most recently opened project at startup and Restore previously open source documents at startup.

Alternatively, within RStudio Desktop we could select File | Open Project… but I’ve never found that very intuitive and somehow I’ve never got used to using RStudio’s command palette. If you have several directories configured as RStudio projects (with .Rproj files) that you’ve opened before you could open those from the top right project drop down menu or double click them from within Finder.

But let’s say we want an even more convenient way of doing this – an icon in the dock. Thanks to this Stackoverflow answer, it turns out that in a terminal we can issue the following open command to achieve opening a new instance of RStudio Desktop (note RStudio Desktop needs to be installed in your Applications directory for this to work).

open -n -a RStudio.app

Making an Automator app to open a new instance of RStudio Desktop

macOS comes with Automator, open that from your Applications directory. Then select File | New and select Application and click Choose. Then from the left most menu select Utilities and double click Run Shell Script. In the main window on the right, leave the shell as zsh and replace the cat text in the box with the open command above.

Then press Cmd + S or File | Save and save your application in your Applications folder. Give the app a distinct name such as RStudio-new-instance.app or whatever you prefer and then quit Automator.

Next we would like our app to have a nice icon.¹

First download a nice icon from say this repo of logos kindly designed for RStudio (I chose the dark one).
Then navigate to the our new app in Finder and press Cmd + I.
Then drag the .icns file onto the icon in the top left corner of the info box. And tada your app will now use this icon!

And you can even drag the app from Finder onto your dock from where you can simply click the icon to open as many instances of RStudio Desktop as you like.

And because the new application is in our Applications directory it is found by Alfred (and hopefully Raycast).

Summary

We have created an Automator application which runs a shell script to open a new instance of RStudio Desktop. We have then given this application a new icon and we have placed this on our dock.

I follow the approach detailed on this blog and on the README where I obtained the icon. ↩︎

The MRC IEU 🚀 R-Universe of Mendelian randomization related R packages

Fri, 26 Jan 2024 14:00:00 +0000

My #GitHubUnwrapped 2023!

Sun, 07 Jan 2024 00:00:00 +0000

My #GitHubUnwrapped 2023!

Made with https://www.githubunwrapped.com/.

Using Git, GitHub Desktop, and GitHub for novice and experienced users

Fri, 01 Dec 2023 11:00:00 +0000

Fuller reproducibility in Stata ado-files and programs: setting the version and user version

Thu, 24 Aug 2023 00:00:00 +0000

Most proficient Stata users have come across the version command. This is an incredibly powerful command, which simply by issuing say

version 18

at the top of a do-file or within a program (typically in an ado-file) means that you have pretty much guaranteed your code will run in the same way when you come to run it later (most likely in a newer version of Stata). But it turns out there’s a subtle difference between issuing version in a do-file/interactively compared to within a program or ado-file.

Several years ago I wrote the reffadjust package ( Palmer et al. 2014) as part of some work using random effects models ( Macdonald-Wallis et al. 2012). It has two programs reffadjustsim and reffadjust4nlcom which use the output of various random effects commands, including those from MLwiN, run from Stata using the user-written runmlwin command ( Leckie and Charlton 2013).

The reffadjust package doesn’t have many users and over the years I hadn’t regularly checked if the programs were still working. But in the ado-files I had set version 13, which gave me some residual confidence that the programs might still work.

However, a few years ago, when I eventually did run some test code I saw that the reffadjustsim tests were failing for MLwiN/runmlwin models. I didn’t have time to investigate further at this point, and I didn’t have any intuition whether the error resulted from a change in MLwiN, runmlwin, or Stata.

At the beginning of this year one of my colleagues mentioned that they were using reffadjust in their work and had observed the same error with reffadjustsim. My guilt kicked in, and I eventually found some time to investigate. I discovered that since I wrote the package, Stata processes matrix row and column stripes (essentially the row and column names) in a more advanced way. This meant that the row and column stripes for covariance elements in the e(V) matrix (the variance-covariance matrix of parameter estimates) from MLwiN/runmlwin models were being renamed when I hadn’t intended them to be, which caused the error.

But wait … I had specified version 13 at the top of my program, so why was this update in later versions of Stata taking effect?

I couldn’t work it out, so I had to ask Stata Technical Support. They were kind enough to tell me that there’s an additional method of invoking the version command which controls what is known as the “user version”. There are some modifications in new versions of Stata which are exempt from the basic invocation of the version command (but only in programs and ado-files). In do-files issuing version sets both the version and the user version, however, in programs and ado-files the “user version”, is set by version #, user, and holds these additional modifications in Stata to the required version.

Naturally, this is explained in the version helpfile and manual entry, which I admit I had not read until this point. Hence, simply editing the top of my program to

version 13
version 13, user

fixed my error. So in a program or ado-file, we require both lines, whereas in a do-file we’d only require version 13.

We can see the different operation of version by the following short example.

/* Do-file/interactive code to set both the version and the user version */
version 13
display c(version), c(userversion), c(stata_version)
// 13 13 18.5

/* Ado-file/program code to set both the version and the user version */
program mytest
version 13
display c(version), c(userversion), c(stata_version)
version 13, user
display c(version), c(userversion), c(stata_version)
end

mytest
// 13 18.5 18.5
// 13 13 18.5

In summary, my reffadjustsim command works again for MLwiN/runmlwin models. The updated version is available from its GitHub repo. And if you ever need fuller reproducibility in your Stata ado-file or program remember to set both the version and the user version.

References

Leckie, George, and Chris Charlton. 2013. “runmlwin: A Program to Run the MLwiN Multilevel Modeling Software from within Stata.” Journal of Statistical Software 52 (11): 1–40. https://doi.org/10.18637/jss.v052.i11.

Macdonald-Wallis, Corrie, Debbie A. Lawlor, Tom Palmer, and Kate Tilling. 2012. “Multivariate Multilevel Spline Models for Parallel Growth Processes: Application to Weight and Mean Arterial Pressure in Pregnancy.” Statistics in Medicine 31 (26): 3147–64. https://doi.org/doi.org/10.1002/sim.5385.

Palmer, Tom M., Corrie M. Macdonald-Wallis, Debbie A. Lawlor, and Kate Tilling. 2014. “Estimating adjusted associations between random effects from multilevel models: The reffadjust package.” The Stata Journal 14 (1): 119–40. https://doi.org/10.1177/1536867X1401400109.

Using allele scores to identify confounding by reverse causation: Studies of alcohol consumption as an exemplar

Mon, 22 May 2023 13:00:00 +0000

My #GitHubUnwrapped 2022!

Sat, 07 Jan 2023 00:00:00 +0000

My #GitHubUnwrapped 2022!

Made with https://www.githubunwrapped.com/.

Make your own CRAN-like repository with Linux binary R packages

Wed, 30 Nov 2022 00:00:00 +0000

Introduction

CRAN is a fantastic resource, in particular because it provides binary packages for Windows and macOS (for both Intel and Apple Silicon Macs). Because there are so many Linux distributions CRAN does not provide binary packages for Linux. Therefore, installing R packages on Linux can be slow because the bundled source packages need to be built on users machines.

But let’s install a package from the Posit (formerly RStudio) Package Manager on Ubuntu Linux.

Woah! Something magical just happened, we installed a binary R package on Linux! How did that happen, let’s find out.¹

Note, obtaining the binary package from the public Posit package manager relies on the R session’s HTTPUserAgent option being set. As I understand it, this is set automatically within an RStudio/RStudio Server session. If you are using R in the terminal you can set this with the following code (if you don’t have this option set you will obtain the source version of the package).

options(HTTPUserAgent =
  sprintf(
    "R/%s R (%s)", getRversion(), paste(getRversion(),
    R.version["platform"], R.version["arch"], R.version["os"])
  )
)

Building bundled source and binary packages

I will use an example of one of my own packages OneSampleMR. I am running RStudio server on Ubuntu Linux, Focal Fossa through Windows Subsystem for Linux.

The package sources are in a Git repository hosted on GitHub, here. There is an .Rproj file, which we open in RStudio as a project.

To build an R package we require all of its dependency packages are installed, so we install those with devtools::install_dev_deps() and if your package requires any system libraries those must be installed too.

The Build pane gives us two convenient options, which will build either the bundled source package or binary package through calls to devtools::build().

Clicking on both in turn we see the following.

The bundled source package has been built as OneSampleMR_0.1.2.tar.gz and the binary package has been built as OneSampleMR_0.1.2_R_x86_64-pc-linux-gnu.tar.gz. Both files are in the directory above the project.

We can achieve the same output by making direct calls to R CMD build and R CMD install --build in a shell if preferred. We can test that these install as follows.

CRAN structure for bundled source package files

In two excellent blog posts Marks Sellors describes how to make a CRAN-like repository.²

To host bundled source packages, such as our OneSampleMR_0.1.2.tar.gz file, we require the following directory structure (noting that the latest directory is optional, but allows us to add snapshot directories if we wanted to).

/mycran
└── latest
    └── src
        └── contrib
            └── 4.3.0
                └── Recommended

Specifically, we place the {package}_{version}.tar.gz files into the .../src/contrib directory. In that directory we then run

tools::write_PACKAGES(type = "source")

which generates 3 additional files (PACKAGES, PACKAGES.gz, and PACKAGES.rds) which R will use to query what packages are available in our repository when its served on the web.

Adding Windows and macOS binary R packages

We saw above how to build a binary Linux package. The same process, when repeated on Windows will generate a file called {package}_{version}.zip and {package}_{version}.tgz on macOS (on Macs with both Intel and Apple Silicon processors).

Assuming that we have some of these files we need to know where to put them. Since CRAN distributes binary packages for Windows and macOS we follow their directory structure, which is as follows.

/mycran
└── latest
    ├── bin
    │   ├── macosx
    │   │   ├── big-sur-arm64
    │   │   │   └── contrib
    │   │   │       └── 4.2
    │   │   └── contrib
    │   │       └── 4.2
    │   └── windows
    │       └── contrib
    │           └── 4.2
    └── src
        └── contrib
            └── 4.3.0
                └── Recommended

Noting that the current version of R is 4.2.2 and that the relevant directory name with the minor version number changes when R’s current minor version number changes, we place

macOS arm64 binary packages (for Macs with Apple Silicon processors) into the .../bin/macosx/big-sur-arm64/contrib/4.2/ directory
macOS x86_64 binary packages (for Macs with Intel processors) into the .../bin/macosx/contrib/4.2/ directory, and
Windows binary packages into the .../bin/windows/contrib/4.2/ directory.

We then run tools::write_PACKAGES(type = "mac.binary") (changing to type = "win.binary" as required) in each of these directories to generate the 3 PACKAGES files.

We can confirm this directory structure using the contrib.url() function (the last command below was run on an Apple Silicon Mac).

contrib.url("", type = "source")
## [1] "/src/contrib"
contrib.url("", type = "win.binary")
## [1] "/bin/windows/contrib/4.2"
contrib.url("", type = "mac.binary")
## [1] "/bin/macosx/contrib/4.2"
contrib.url("", type = "binary")
## [1] "/bin/macosx/big-sur-arm64/contrib/4.2"

And they are also listed in the R Installation and Administration manual.³

On Apple Silicon Macs the big-sur-arm64 filepath corresponds to the end of .Platform$pkgType.

.Platform$pkgType
## [1] "mac.binary.big-sur-arm64"

Where to store and how to name Linux binary R packages?

CRAN does not distribute Linux binary packages and so there is no directory structure from them to copy.

However both the Posit Package Manager and the R4Pi project achieve this in a very clever way.⁴

We saw above that on Linux bundled source packages have filenames of the form {package}_{version}.tar.gz whereas the binary package filenames are of the form {package}_{version}_R_x86_64-pc-linux-gnu.tar.gz (the text after {package}_{version}_ may be different depending on your machine and distro).

To distribute the Linux binary packages we create a parallel directory structure, which takes the same form as for the bundled source packages. In the case of Ubuntu Focal Fossa the Posit Package Manager uses __linux__/focal/latest/src/contrib.

They then rename the {package}_{version}_R_x86_64-pc-linux-gnu.tar.gz files to the same form as the bundled source package files, i.e., to {package}_{version}.tar.gz. And they put them in this new src/contrib directory.

The structure of our CRAN-like repository (well in fact our 2 parallel repositories) is now.

/mycran
├── __linux__
│   └── focal
│       └── latest
│           └── src
│               └── contrib
│                   └── 4.3.0
│                       └── Recommended
└── latest
    ├── bin
    │   ├── macosx
    │   │   ├── big-sur-arm64
    │   │   │   └── contrib
    │   │   │       └── 4.2
    │   │   └── contrib
    │   │       └── 4.2
    │   └── windows
    │       └── contrib
    │           └── 4.2
    └── src
        └── contrib
            └── 4.3.0
                └── Recommended

We then run

tools::write_PACKAGES(type = "source")

in the .../__linux__/distro-name/src/contrib directory for each Linux distribution to generate the PACKAGES files.

Once this directory structure is served we can set our repository in R to .../__linux__/focal/latest and R will find the binary package {package}_{version}.tar.gz files in the ...__linux__/focal/src/contrib/ directory, as per the first figure in this post.

Note that the {package}_{version}.tar.gz files within __linux__/focal/latest/src/contrib do not all have to be of binary packages. They can be a mix of bundled source and binary packages, which is helpful if you haven’t had time to build all your binary package files.

We can also confirm that on Ubuntu Focal Fossa

.Platform$pkgType
## [1] "source"

therefore, on Linux, utils:::resolvePkgType() always returns "source". Hence, on Linux, contrib.url() always returns /src/contrib regardless of its type argument.

Testing your CRAN-like repositories locally

You can either run a local web server or use the file://... URL notation as your repos global options setting (set with option(repos = ...) or as the repos argument to install.packages()).

Here’s a screenshot of installing a binary package on Ubuntu Focal Fossa.

Summary

We have taken a look at the structure of a CRAN-like repository and built bundled source and binary package files. We saw that the trick for distributing Linux binary packages is to make a parallel directory with the same structure as that required for bundled source packages and that we need to rename the binary package files to have the same filename format as the bundled source package files.

Note that there are other approaches to distributing binary R packages on Linux, see https://cran.r-project.org/bin/linux/ and links therein, https://eddelbuettel.github.io/r2u/, and https://enchufa2.github.io/bspm/. ↩︎
https://blog.sellorm.com/2019/03/29/lifting-the-lid-on-cran/ and https://blog.sellorm.com/2019/03/30/build-your-own-cran-like-repo/] There is also the miniCRAN package to help do this, but we don’t need to use this for the following explanation. ↩︎
See https://cran.r-project.org/doc/manuals/R-admin.html#Setting-up-a-package-repository. ↩︎
See https://packagemanager.rstudio.com/client/#/repos/2/overview and https://pkgs.r4pi.org/ ↩︎

A review of group-based methods for teaching statistics in higher education

Wed, 29 Jun 2022 16:20:00 +0000

Investigating and fixing a new CRAN check error in my OneSampleMR package

Fri, 20 May 2022 11:30:00 +0000

R and Stata packages for one-sample Mendelian randomization analyses: OneSampleMR and ivonesamplemr

Thu, 20 Jan 2022 13:00:00 +0000

Parameter collapsibility and noncollapsibility in statistical models: what you need to know

Mon, 18 Jan 2021 13:00:00 +0000

bpbounds: R package and web app

Wed, 17 Jul 2019 00:00:00 +0000

Directed acyclic graphs: what are they and what are they useful for?

Tue, 04 Dec 2018 12:00:00 +0000

mrrobust: A Stata package for MR-Egger regression type analyses

Fri, 08 Sep 2017 00:00:00 +0000

mrrobust: A Stata package implementing MR-Egger regression type analyses

Wed, 12 Jul 2017 13:00:00 +0000

Corrected standard errors for two-stage residual inclusion estimators and a Stata package for MR-Egger regression type analyses

Thu, 20 Apr 2017 13:00:00 +0000

Some topics from Mendelian randomization

Tue, 07 Mar 2017 12:00:00 +0000

Meta-analytic structural equation modelling: Application to Mendelian randomization studies

Thu, 14 Apr 2016 12:00:00 +0000

Fitting fixed and random effects meta-analysis models using structural equation models

Thu, 27 Aug 2015 13:00:00 +0000

Corrections to Probit and logistic control function estimator standard errors for marginal parameters

Mon, 22 Jun 2015 13:00:00 +0000

Lack of identification in structural mean models and multiple paired comparisons for investigating pleiotropy

Tue, 09 Sep 2014 12:00:00 +0000

Generalised method of moments estimation of mediation models and structural mean models

Wed, 12 Mar 2014 13:00:00 +0000

Topics in instrumental variable estimation: structural mean models and bounds

Thu, 07 Nov 2013 16:00:00 +0000

Strengthening Mendelian randomization through utilizing multiple independent paired combinations of genetic variants to evaluate potential pleiotropy

Mon, 26 Aug 2013 13:00:00 +0000

Topics in instrumental variable estimation: structural mean models and bounds

Thu, 30 May 2013 17:00:00 +0000

Generalised method of moments estimation of mediation models and structural mean models

Wed, 15 May 2013 09:00:00 +0000

Topics in instrumental variable estimation: structural mean models and bounds

Wed, 01 Feb 2012 13:00:00 +0000

Generalised method of moments estimation of structural mean models

Thu, 15 Sep 2011 00:00:00 +0000

Estimation using structural mean models with multiple instruments

Wed, 14 Sep 2011 13:00:00 +0000

Generalised method of moments estimation of structural mean models

Tue, 23 Aug 2011 13:00:00 +0000

Estimation of structural mean models with multiple instruments

Thu, 26 May 2011 13:00:00 +0000

Mendelian randomization: using genotypes as instrumental variables in epidemiological studies

Thu, 10 Feb 2011 16:00:00 +0000

Using multiple independent combinations of genetic variants to strengthen causal inference in Mendelian randomization studies: height and lung function as an example

Wed, 15 Sep 2010 13:00:00 +0000

Instrumental variable estimation of the causal risk ratio in cohorts

Mon, 30 Aug 2010 13:00:00 +0000

Including multiple instrumental variables in Mendelian randomization analyses

Sat, 14 Nov 2009 12:00:00 +0000

Contour enhanced funnel plots for meta-analysis

Fri, 11 Sep 2009 13:00:00 +0000

Including multiple instrumental variables in Mendelian randomization analyses

Wed, 26 Aug 2009 13:00:00 +0000

Performing Bayesian analysis in Stata using WinBUGS

Mon, 10 Sep 2007 13:00:00 +0000

An adjusted instrumental-variable model for Mendelian randomization

Sat, 08 Sep 2007 00:00:00 +0000

Meta-analysis of Mendelian randomization studies

Wed, 01 Aug 2007 13:00:00 +0000

Meta-analysis of Mendelian randomization studies

Thu, 12 Apr 2007 13:00:00 +0000

Incorporating measures of study similarity in a meta-analysis

Wed, 30 Aug 2006 17:00:00 +0000