Reusable by Default

Reflections on Building Sustainable Open Tools
and Knowledge for Healthcare

Sammi Rosser

               

Picture a Scene

I want you to picture a scene.

You’ve been asked to do something pretty complex, pretty quickly. It also sounds like something someone else will have worked on before. It’s got that sense of ‘this isn’t just an “us” problem’.

So you go out and ask around on - say, the NHS-R Slack - if this is something someone else has worked on.

And you get the response - “yes!”.

(but it was at my previous job and I wasn’t allowed to share the code, so I don’t have it anymore. But you could try asking so-and-so, and here’s a bit of a rough guide of what we did. )

And then someone else chimes in…

“yes! I’ve got a repository. Here’s the link. It’s been a while since I’ve used it, though.”

The repository has loads of folders and files with no obvious naming convention. It’s not clear where you should go. There are no tests. The last commit was 2 years ago.

And then you see the readme and your heart sinks. And they’re probably busy and don’t have time to go back - if they can even remember. So you poke around a bit but you don’t know what the data is meant to look like, and

And I will fully admit I’ve been the people on both sides of this conversation. Where I’ve done something I think will be of use and shared it in a sort-of-usable state, but life’s then got in the way, and I can’t spare the time to go back into a project to polish it up properly - because I was too busy and the next thing was on fire.

Who am I to come here and talk about this?

Now that we’ve established that hopefully familiar narrative, who am I to try and propose a solution?

So, I’m Sammi Rosser. I had my first taste of “proper” coding about 14 years ago, in the deep dark ages of base R, but I’ve been coding in earnest for about 10 years now. These days it’s mostly Python, but I’m astill big fan of R too.

I have an MSc in health data science, and spent two years working as a data analyst and then data scientist in a mental health trust where some people from this community had really laid some amazing R foundations in the team. And I came to my first NHS-R conference in 2022, I was just completely in awe of all the amazing things people were doing. So I spent my time at the coal face of data, automating reports, writing a script to automate the upload of 80,000 documents after an EPR outage. What I’m trying to say is, as we go through this talk - I know the realities, and the time pressures, and the priorities of data work in the NHS.

But my passion is sharing the joy of code with other people - so I joined the Health Service Modelling Associates programme in 2023. So now I get to teach people all the really fun, interesting and impactful things they can do with code, and I get to do a lot of coding, including recently on a big complex cross-organisation modelling projects to keep my skills sharp.

The Problem

I get to meet loads of amazing people across different organisations. 9 months of the programme, people work on projects. People have been doing amazing things with their projects, and this has been true of HSMA for years.

https://hsma.co.uk/previous_projects/projects_with_code

And last year, I was revamping our website to try and help our students come up with ideas around ‘what sorts of projects can I do?’. And I was looking at all this code that’s been written by our community and shared over the years

But even where the code was shared, we just weren’t getting people reusing it. Even people within the HSMA community, even when they had the same problem, even when we could direct them to a previous repo - they would end up starting from scratch each time.

I keep seeing the
same few simple(ish) things
holding otherwise great repositories back

And looking at them, I kept seeing the same things that trip up a lot of people newer to coding and open source

These are issues not unique to our projects and students - these are things you see time and time again in open source projects, but they’re resolvable if you get into some good habits.

And they’re the things that can really help level up your projects. Many of them aren’t that time consuming - and they might even save you time in the future.

The utopia we want to reach

https://statsrhian.github.io/nhsrpysoc-reusable/

And that’s the main thing I want to talk you through today - how are we going to reach the utopia that people in previous years have talked about - like Rhian Davies’s fantastic talk from last year?

But I want to focus on some of the practical things we can all start doing by default.

Reproducible PLUS Reusable

The Tapestry of ‘Reusable by Default’

So I want to take you through my tapestry of ‘reusable by default’. Or it might be a quilt.

My Proposals

• Some take almost no time

• Those that take time often save time in the long run

• They don’t all need to happen at once (or all of them always)

• But how much longer can we afford to NOT do them?

Some of them are just doing things in differnt places

This is the ‘why’ - find the ‘how’ on my website

sammirosser.com

In this talk, I want to convince you of why you should bother with each of these things.

I don’t have time to take you through all the details of the how - but head to my website and you can find a blog post with all of the juicy details.

Ready?

(or any online repository hosting)

• On GitHub > emailed/Slacked/available on request

• Not ready to use it in full? Drag and Drop.

• Borrow repo templates from other people!

• Heightens impact of some of the other elements…

Other services exist, but the party is happening over on GitHub

Over 17 orgs listed (I know there are more) and over 2000 repos!

When I say ‘write like it will be open’

• If you don’t add a licence, I can’t use your code!

• Yes, even if you emailed it to me (unless you were clear)

• It’s one ‘special’ file (LICENCE or LICENCE.md) GitHub recognises

• Sites exist to help you pick (choosealicense.com/)
  • MIT & GPL3 are a good place to start

• Once you settle on one, it’s a 1 minute job

• A licence is the first and most fundamental step towards reusability.
• Once you know a few of them, you can chuck one in there from the start.
• LICENCE or LICENCE.md = special file that will be displayed by github
• If you don’t have one, I cannot reuse your code
  • default law = no rights to use, modify, etc.
• If you create it via Github, it helps you choose one and make the file!
• MIT is a pretty decent option
• ChooseALicence helps if you’re unsure

If you don’t have a readme, you could be taking hours of each persons’ time

• Tell me how to use it
  • installing environment
  • what to run and how
  • data format required

• Tell me why I should bother

• Tell me how it’s doing what it’s doing

README.md is a special file GitHub will display

README.md is a special file because Github will display it.

Use it to tell me how to run your code, what inputs I need, etc. - all the key important stuff I need to know if I want to run it myself. What’s in all those folders?

You might notice I don’t talk about environments today - and that’s not because it’s not important, but because plenty of other people have spoken on that matter. So here I’m almost assuming you’re doing that, and expecting it to be in your readme.

The ‘why should I bother’ is the bit I actually see being missed out the most. What will I get out of this?

But also the ‘what’ - is this a simulation? A forecasting library? For long term planning or short term operational use? It’s often so unclear and just a couple of sentences clear that up straight away.

So a readme doesn’t need to be long - but please don’t just leave me with a one liner and 10 folders each with 6 notebooks in (and this is a real scenario I’ve encountered)

# vidigi (Visual Interactive Dynamics and Integrated Graphical Insights)

Welcome to vidigi - a package for visualising real or simulated pathways.

https://github.com/hsma-programme/vidigi/vidigi_video.mp4

## Getting started

Head to the [documentation](https://hsma-tools.github.io/vidigi/vidigi_docs/)
to find out how to create an animated version of your model.

You can install vidigi from PyPi with the command `pip install vidigi`.

• Docstrings are super-comments

Docstrings are one of the easiest way to level up your code - for you and others.

They’re basically super-comments that the tools you write your code in - your IDE, like RStudio or VSCode, will display.

In python, lots of formats - choose one you like and stay consistent

In R, roxygen2 and the ‘docstring’ package

And you write them like this (in )

Allowed to use AI? Rope it in!

And if you can’t use AI, there are still tools that will set up the structure.

Those docstrings you just wrote?

Combine them with pdoc, sphinx, quartodoc, or mkdocs (for )

Or pkgdown (for )

Voila - website with all your code documented

You can host your documentation for free with just a few clicks

They generate a dictionary

(this is Quartodoc)

And display your docstrings

(this is Quartodoc)

A plea…

I will not be reading your code if it’s written like this…

df=pd.read_csv("sales.csv").dropna(subset=["price","quantity"]).assign(total=lambda d:d["price"]*d["quantity"]).query("total>1000").groupby(["region","category"],as_index=False).agg({"total":"sum","quantity":"mean"}).sort_values("total",ascending=False).rename(columns={"total":"total_sales","quantity":"avg_quantity"}).reset_index(drop=True).head(10)

But I will if it looks like this

df = (
    pd.read_csv("sales.csv")
    .dropna(subset=["price", "quantity"])
    .assign(total=lambda d: d["price"] * d["quantity"])
    .query("total>1000")
    .groupby(["region", "category"], as_index=False)
    .agg({"total": "sum", "quantity": "mean"})
    .sort_values("total", ascending=False)
    .rename(columns={"total": "total_sales", "quantity": "avg_quantity"})
    .reset_index(drop=True)
    .head(10)
)

• Install a linter like ruff for python

• R equivalents exist in RStudio and Positron

• Set it to format on save = never faff with formatting again!

And it just helps save time - which you can use on other parts of this list!

• Safe linters are available for all good languages and IDEs
• Format on save = never deal with this again

This is one thing I wish I’d done years ago

• Choosing a future-proof folder structure from the start saves effort down the line (for Python in particular)

• Avoid putting your script files in the repository root

• It costs very little once you get used to it

• Other things (like auto-documentation) will just work

I had to completely restructure something recently and it was a colossal pain

• Pros and cons of python options here

• Consider structuring resuable parts of analysis scripts within an R package structure

myproject/
├── analysis.ipynb
├── main.py
├── utils.py
├── README.md
├── requirements.txt

myproject/
├── analysis.ipynb
├── pyproject.toml
├── README.md
├── requirements.txt
└── src/
    └── myproject/
        ├── __init__.py
        ├── main.py
        └── utils.py

• Automated tests are small scripts that check your code (still) works as expected

• They give you and others confidence in your code

• You (or they) instantly know if changes have caused problems

• Overall, they save you heaps of time

• pytest in

• testthat in

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

• Or a certain thing never happens in a simulation
  
• Or you have the same number of rows after a join
  
• etc.

• GitHub has fantastic free project tracking tools built in

• Helps you to keep track of what you haven’t done yet

• Helps others understand what’s left to happen (and maybe pitch in)

Issues

Projects

A mindset shift

Where are we now?

Last chance…

Remember our plea from the start?

What do you do every time you start a new script?

import pandas as pd

library(ggplot2)

Or maybe…

library(NHSRPlotTheDots)

I think it’s easy to see packages as something for ‘other people’

For ‘advanced coders’

But it’s like any other coding task

And the things we’ve talked about mean you’re basically there!

• We need to start identifying the bits of the work we do that we can turn into reusable elements

• Look for patterns and repetition

• Write more functions

• Think how to accept elements as arguments instead of hard coding them

What about that special kind of plot you’ve created?

Or something that takes input data, chooses the best forecasting model, does the forecast and churns out predictions and intervals?

An animation of a model for a workshop…

Became vidigi

This moved away from hard coding the input data and expecting certain column names.

There’s a lot to be said for contributing to other packages

But I’d say writing your own is less scary - and perhaps the way to start

But in the long run, many hands can make light work

Summary

You don’t always know what will be worth sharing and reusing when you start

But these steps

• Unlock possibilities

• Make your life easier

• Make your teams’ life easier

• Accelerate your learning

These pieces set the stage

The Final Hurdle

I worked in a trust with some brilliant people, but I was still pretty new to all of this.

One of my biggest frustrations was being asked questions that I just didn’t know the right way to answer… but I was sure someone out there would have thought about this before.

We have different systems, and different pathways, but I’m far from the first person to be standing up here yelling about having the same problems and repeated solutions.

And it actually makes me a little mad because we shouldn’t, in 2025, be experiencing a postcode lottery of whether our trust has a data science team, and advanced analytics capabilities. I know if I was treated in trust X it’s by a team who are making advanced predictions of demand, and I’m going to be seen in a more timely manner.

The challenge

Since I joined the NHS, I’ve been trying to find all the good stuff

NHS R conference, HACA conference, SWAIH conference, SWAIH South West Hub, LinkedIn, starring over 1300 Github repos, working out which individuals and organisations to follow on GitHub. Attending HaCORN and HaCORN special interest groups and NHS-R webinars and HSMA showcases and ApHA stuff and reading NHS-R and Pycom and subscribing to newsletters and talking to academics and the strategy unit and …

There just isn’t enough time (and brainspace) for us all to be constantly trying to do this.

And that’s just locked in my head.

How many of us are trying to do the same thing and build up knowledge that would be better externalised?

And I’m not saying that we get rid of any of these things because each and every one of them is wonderful and a necessary part of this huge puzzle that is modern analytics in the NHS - but

We don’t just need to get things into packages.

We need to get them out there into the hands of the people who need them.

And we have pockets of it. - the HSMA website, which you can filter down to projects with shard code - the fabulous NHS-R website and books - bits and pieces on github - maybe things I can’t see (like AnalystX)

There are so many parts to that puzzle slowly going together, but I still don’t feel like I have that ‘magic book’ that I felt must exist when I started my NHS journey.

So I’ve begun to write that.

The Healthcare Services Analytics & Decision Science Atlas

atlas.hsma.co.uk

What next?

I can’t do this alone!

Contribute

Submit a project code-free via the form or read advanced instructions in the README

Get in touch

Add Me On LinkedIn - Sammi Rosser

Follow Me On GitHub - Bergam0t

Watch other talks @ sammirosser.com

Email me - hi@sammirosser.com

Check out HSMA - hsma.co.uk

Acknowledgements

Slack chat mockups generated from chatmockup.com

Images generated with DALL-E3 or ChatGPT-5

Cheers icons created by Konkapp - Flaticon

Hex stickers built on Canva (all images used via Canva Pro subscription)

The STARS project team for their work on reusability

Pub image from Shaun of the Dead (Universal Pictures).

Huge thanks to Dr Dan Chalk and all of our HSMAs

And many thanks to the NIHR/PenARC for funding us!