Byte-sized RSE

Byte-sized RSE is a series of events providing key research software skills in just 1 hour!

Run by the UNIVERSE-HPC project, the byte-sized RSE series began in October 2022. We are currently running the third and final series of sessions during the 2024-25 academic year.

Each session has a companion podcast episode in the Code for Thought podcast series.

See below for details of upcoming sessions and links to podcasts and other outputs from previous byte-sized RSE sessions.

Our byte-sized RSE events are run under the UNIVERSE-HPC Code of Conduct.

For any questions related to the series, or if you’d like to run a session on a topic that we’ve not yet covered, you can get in touch with Jeremy Cohen or Steve Crouch.

Future Byte-sized RSE events

Photo by Max Shturma on Unsplash

Series 3, Episode 3: The value of User Experience (UX) design

Date: Thursday 30 January, 2025  13:30-15:00 GMT

Instructors: Meag Doherty

Links:

Registration: Register here

This session explores how to ensure the value of design is recognized and integrated into research projects. You’ll learn how to effectively convey the importance of usability to PIs and senior management, demonstrating how good design enhances research outputs by aligning tools and workflows with user needs. We’ll cover strategies for pitching time to focus on usability aspects, emphasizing how early investment in intuitive design saves time, reduces bottlenecks, and improves scientific output down the line. By the end of this session, you’ll be equipped to advocate for design as a critical component of research success and drive better outcomes through thoughtful, user-centered approaches.

Prerequisites: Attendees should have an introductory knowledge of UX Design (see Mark Turner’s 2024 episode).

Past Byte-sized RSE events

Photo by Google DeepMind on Unsplash

Series 3, Episode 2: Psychology of data visualisation

Date: Friday 10 January, 2025  13:00-14:30 GMT

Instructors: Philly Broadbent and Eirini Zormpa

Links:

Registration: Register here

In the second episode of season 3 of byte-sized RSE, we’ll be looking at how to create clear and effective data visualisations, that take into account how human perception works. Data visualisations take data and turn them into pictures. How those pictures, and by extension the data, are understood will be affected by the ways that the human visual system interprets the world. In the first part of the session, you will learn about relevant visual illusions, visual variables, and Gestalt principles that you should be aware of when creating your plots. In the second part of the session, you will get some hands-on experience with improving data visualisations that disregard the principles covered in the first session.

Prerequisites: In order to be able to participate in the practical/interactive part of this session, you’ll need to be comfortable creating visualisations in the programming language of your choice. Demonstrations will be done using R and the ggplot2 package.

Photo by Bernd Dittrich on Unsplash

Series 3, Episode 1: Containers with podman

Date: Wednesday 27 November, 2024  13:00-14:30 GMT

Instructors: Jeremy Cohen and Steve Crouch

Links:

Registration: Register here

Byte-sized RSE is back! In this first episode of season 3 of this series of short technical tutorials, we’ll be looking at containers. Containers provide a form of lighweight operating system-level “virtualisation” where a single operating system/kernel instance is able to support multiple isolated environments. Within these environments, which are referred to as containers, applications are provided with a space that looks effectively like a separate computer system, even though multiple such containers may be running on a single operating system via a single kernel. Containers can offer much better performance than full virtual machines while offering many of the benefits. Container technologies have been around for some time and have been popularised most notably in recent years by the widespread use of Docker. In this session, we’ll be using a fully open source container engine, Podman, to demonstrate the use of containers. However, if you’re keen to work with Docker, the material that we cover in this session will work with Docker too.

Prerequisites: In order to be able to participate in the practical/interactive part of this session, you’ll need to install and test podman on your computer prior to the session.

There are detailed instructions about installing podman on the podman website but we’ve also provided some futher information on podman, why we’ve chosen to use it and installing podman on Linux, macOS or Windows at: https://www.universe-hpc.ac.uk/resources/byte-sized-rse/podman-info

Photo by Agenlaku Indonesia on Unsplash

Series 2, Episode 8: Python packaging and pip

Date: Friday 21 June, 2024  13:00-14:30 BST (UTC+1)

Instructors: Jeremy Cohen and Steve Crouch

Links:

Registration: Register here

In this final episode of season 2 of byte-sized RSE, we’ll be looking at Python packaging. We’ll do this from both the user and package creator perspective. There are different package infrastructures in Python and we’ll focus here on the core packaging ecosystem maintained by the Python Packaging Authority (PyPA) and the pip package installer tool.

We’ll begin by looking at the use of pip to install packages and what actually happens when you install a package. Then we’ll look at the anatomy of a Python package and create a simple package ourselves, to see how one is structured and built.

Prerequisites: In order to be able to participate in the practical/interactive part of this session, you’ll need a computer with a regular Python installation (i.e. not Anaconda) and pip available. You’ll also need some basic familiarity with working on the command line and be familiar with a command line-based editor such as nano, vi or emacs to enable you to easily edit files. The tutorial may also work using pip via Anaconda but this is not a supported setup for this session.

Photo by Ilya Pavlov on Unsplash

Series 2, Episode 7: FAIR Research Software for Reproducible Research

Date: Tuesday 4 June, 2024  13:00-14:30 BST (UTC+1)

Instructors: Aleksandra Nenadic

Links:

Registration: Register here

This session will look the FAIR principles - Findable, Accessible, Interoperable, and Reusable - as applied to software and look at how they help to support reproducibility of your research outputs.

Further detail and session pre-requisites to follow.

Photo by Christina @ wocintechchat.com on Unsplash

Series 2, Episode 6: Property-based testing in Python

Date: Friday 19 April, 2024  13:00-14:30 BST (UTC+1)

Instructors: Steve Crouch, Jeremy Cohen

Links:

Registration: Register here

This session will look Property-based Testing using Python. This is a form of automated testing that applies a range of values to key properties to try and identify failure cases in your code. For a much more detailed discussion of what property based testing is (and isn’t!), take a look at this article.

The session will provide a general introduction to the topic followed by an interactive tutorial where you’ll have a chance to try out writing your own tests. Please note that to participate in the interactive part of the session, you’ll need Python installed on your computer and be able to install new Python libraries with the pip package management tool. We’ll do this via a virtual environment so you won’t require admin access if you have Python, pip and venv available. We also recommend that you some basic familiarity with writing tests in Python via Python’s unittest framework, pytest or a similar testing library. You’ll also need to have Git installed since we’ll be cloning an example repository from GitHub which will contain some initial content for the interactive exercises.

Photo by Martin Adams on Unsplash

Series 2, Episode 5: Citation File Format (CFF) and cffinit

Date: Tuesday 19 March, 2024  10:00-11:00 GMT

Instructors: Stephan Druskat, Abel Siqueira

Links:

Registration: Register here

Creating software for research in an academic setting brings a few extra obligations compared to when you work in industry. For example, research software should be FAIR (Findable, Accessible, Interoperable and Reusable) to make research reproducible. Citing software is an important building block in this, but it’s sometimes not easy to find the relevant correct metadata for software. You can support the researchers using your software by making this information available in a CITATION.cff file in the Citation File Format (CFF). This is also good for you to get recognition. CFF is a plain text format based on YAML that provides the relevant fields for enabling the correct citation of software. This session will start off by introducing CFF, and then continue with an interactive session using cffinit.

cffinit is the best visual tool to get you started with creating CFF files, or editing existing ones. It helps you automatically validate your CFF file from your browser – you don’t need to install anything on your computer.

Beyond cffinit, the Citation File Format is integrated with other existing platforms and tools. At the end of the session, we will demonstrate how your CFF file automatically improves the metadata for publications of your software in the open access repository Zenodo.

Photo by Kelly Sikkema on Unsplash

Series 2, Episode 4: User Experience (UX) Design

Date: Tuesday 27 February, 2024  12:00-13:00 GMT

Instructors: Mark Turner

Links:

Registration: Register here

This session will provide an introduction to UX Design.

UX design is the process of creating the experience a user would go through when interacting with your application. It is so much more than the visual aesthetic, it encompasses usability, usefulness and overall performance. This interactive session will look at two important UX design skills. Firstly we will take a scenario from an initial design, through end user input and context of use. Secondly we will explore the impact of UX design choices in the tech around us as a way of understanding the consequences of the design decisions we make.

Photo by Alexander Tsang on Unsplash

Series 2, Episode 3: Introduction to EasyBuild

Date: Tuesday 23 January, 2024  11:00-12:30 GMT

Instructors: Jörg Saßmannshausen

Links:

Registration: Register here

This session will provide a high-level introduction to the software build and installation framework EasyBuild (https://easybuild.io/).

EasyBuild is focused on supporting the installation of software on High Performance Computing (HPC) platforms and is increasingly widely used as a tool to simplify this process. Following a short introductory presentation, there will be an opportunity to see how EasyBuild works as part of a hands-on interactive tutorial.

Please note the prerequisites (detailed on the sign-up form) for participating in the interactive part of this session - you may need to find a suitable Linux-based platform on which to undertake the tutorial and install some required software dependencies.

Photo by Ilya Pavlov on Unsplash

Series 2, Episode 2: Python Web Application Development with Django

Date: Tuesday 5 December, 2023  13:00-14:30 GMT

Instructors: Jeremy Cohen and Steve Crouch

Links:

This session looks at the development of web applications with Python using the Django web framework.

It will begin with some general background on web framework and application structures and then look at where Django fits in and its architecture.

After looking at the structure of Django and the different parts of a Django application, we’ll move on to the interactive part of the session where you’ll have a chance to build a simple Django web application from scratch!

Photo by kvalifik on Unsplash

Series 2, Episode 1: Software Task Estimation

Date: Tuesday 7 November, 2023  13:00-14:00 GMT

Instructors: Peter Schmidt

Links:

In the first session of season 2 of byte-sized RSE, we’ll look at that challenging question that many software developers or researchers will be familiar with being asked: “How long will it take?”!

It’s also the question most, if not every, software engineer dreads! Often, it feels like asking: “how long is a piece of string?”

Luckily, there are some common techniques and practices we can use to help us to give reasonable estimates and avoid common pitfalls. In this session, we’ll be looking at and trying out a couple of them.

Photo by Shahadat Rahman on Unsplash

Research Software Camp #5: Git Version Control - Beyond Beginner Level

Date: Wednesday 28 June, 2023  10:00-12:00 BST

Instructors: Jeremy Cohen and Steve Crouch

Links:

A re-run of Byte-sized RSE session 7 from series 1 as part of the 5th SSI Research Software Camp, which looked at intermediate and advanced use of Git version control. This included looking at the feature branch workflow model and features such as rebasing and cherry-picking.

A companion podcast is now available as part of the Code for Thought series.

Photo by Mimi Thian on Unsplash

Research Software Camp #5: Code Review

Date: Friday 23 June, 2023  10:00-12:00 BST

Instructors: Jeremy Cohen and Steve Crouch

Links:

A re-run of Byte-sized RSE session 2 from series 1 as part of the 5th SSI Research Software Camp, which looked at collaboration and code review via GitHub.

A companion podcast is now available as part of the Code for Thought series.

Photo by Aaron Burden on Unsplash

Series 1, Episode 8: README files

Date: Tuesday 6 June, 2023  13:00-14:00 BST

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 8 looked at README files. Not a default and often ignored file in the top-level folder of your project but a hugely important place for a range of information that can make or break the success of your project - either inspiring potential users to adopt your software or contribute to your project, or, putting them off entirely and sending them running in the direction of a competing tool or codebase!

A companion podcast is now available as part of the Code for Thought series.

Photo by Desola Lanre-Ologun on Unsplash

Series 1, Episode 7: Intermediate/Advanced Git

Date: Wednesday 10 May, 2023  13:00-14:30 BST

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 7 looked at intermediate and advanced use of Git version control. This included looking at the feature branch workflow model and features such as rebasing and cherry-picking.

A companion podcast is now available as part of the Code for Thought series.

Photo by Riku Lu on Unsplash

Series 1, Episode 6: Integrated Development Environments (IDEs)

Date: Tuesday 28 March, 2023  13:00-14:30 BST

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 6 looked at how Integrated Development Environments (IDEs) can help you to be more efficient in writing, managing and debugging your code.

A companion podcast is now available as part of the Code for Thought series.

Photo by Chris Ried on Unsplash

Series 1, Episode 5: Code Style and Linting

Date: Tuesday 28 February, 2023  13:00-14:30 GMT

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 5 looked at the importance of code style in supporting readability and maintainability of your code. We also looked at tools for checking your code for potential errors (linters) and checking for conformance with styling specifications.

A companion podcast is now available as part of the Code for Thought series.

Photo by Taylor Vick on Unsplash

Series 1, Episode 4: Continuous Integration

Date: Tuesday 17 January, 2023  13:00-14:00 GMT

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 4 looked at Continuous Integration providing some background on the topic and then focusing on the use of GitHub Actions to set up a pipeline to automatically run tests and related processes on your codebase in response to specific actions such as merging new code.

A companion podcast is now available as part of the Code for Thought series.

Photo by Hush Naidoo on Unsplash

Series 1, Episode 3: Testing your Python code

Date: Tuesday 13 December, 2022  13:00-14:00 GMT

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 3 looked at testing your Python code. The session started with a general introduction to software testing applicable across many languages followed by an interactive tutorial based on testing of Python code.

A companion podcast is now available as part of the Code for Thought series.

Photo by Desola Lanre-Ologun on Unsplash

Series 1, Episode 2: Collaboration and Code Review via GitHub

Date: Tuesday 15 November, 2022  14:00-15:00 GMT

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 2 looked at collaboration and code review via GitHub.

A companion podcast is now available as part of the Code for Thought series.

Photo by JESHOOTS on Unsplash

Series 1, Episode 1: Software Licensing

Date: Tuesday 18 October, 2022  13:00-14:00 BST

Instructors: Jeremy Cohen and Steve Crouch

Links:

Byte-sized RSE session 1 looked at open source software licensing.

A companion podcast is now available as part of the Code for Thought series.