Monday 26 October @ 14:00 - 17:00

The Carpentries certified instructor and trainer, Yanina Bellini Saibene has put together this R introductory course for new or beginner coders. “From spreadsheets to R” is intended for people who use spreadsheets for data manipulation and analysis, but have never programmed and would like to learn how to work with R. This course aims to answer questions such as: "Why use R?" and "Where to start?"

Yanina will work with R in an orderly and reproducible way, using a workflow that allows those who take this course to apply good programming practices, work collaboratively and present their work in a single document that includes the analysis and the results.

Whenever she can, Yanina will indicate how the issues she proposes to solve with R can also be solved with spreadsheets and the advantages and disadvantages in each case.

Each section includes exercises and challenges together with the examples and uses some useful data sets for the problem we want to solve. These data is realistic so that anyone can find similarities with their own data and can apply what they have learned to other situations.

Pre-workshop requirements

Please install R and RStudio.

Tuesday 27 October @ 09:30 - 12:30

Responsible Research Outputs: Structuring, Sharing, and Showcasing Code and Data with FAIR and CARE

Does your research project feel like a chaotic folder? You are not alone. Are you getting full credit for your work? Wondering how to share code, data, research output ethically, get proper credit, or make them truly reusable? This workshop transforms that chaos into a polished, citable, and responsible research portfolio. We will guide you through the entire release lifecycle—from structuring your folders to publishing a professional project webpage that showcases your code, datasets, and papers with clear citations and ethical safeguards.

Why Organise, Share, and Make Your Research Outputs CCitable?

Get Proper Credit: Extract more benefits from your code and datasets so they count as academic outputs—just like papers.

Protect Sensitive Data: Learn how to apply the CARE principles so you share data responsibly, respecting community sovereignty and consent.

Make Your Work FAIR: Apply the core principles to ensure your software and data can be discovered and used by others—boosting your impact and collaborations.

Build a Professional Portfolio: Create a clean GitHub Pages website that acts as a single, impressive page for all your research outputs.

What You'll Learn:

Project Hygiene and Organisation: Design standardised folder structures and machine-friendly file naming conventions that work seamlessly.

FAIR + CARE Metadata and Documentation: Write robust READMEs and ethics/governance files that clearly document access restrictions, and reuse conditions.

Licensing: Choose the right licenses for code and datasets.

Sharing: Deposit code and datasets and build a central GitHub Pages webpage that showcases your projects.

By the end of this workshop, you will have a complete "release checklist" and the practical skills to confidently transform any messy research project into a well-organised, ethically shared, and fully citable web presence that impresses supervisors, researchers, and future employers.

Requirements

A free GitHub account (free) and basic familiarity with navigating files and folders on your computer. No advanced coding experience is required—this workshop focuses on best practices, tools, and workflows that work for any programming language.

Wednesday 28 October @ 13:30 - 15:00

Basic Git training usually covers the essential concepts, such as adding files, committing changes, pushing to a remote repository to share or backup your code, viewing commit history, and checking out or reverting to earlier versions. But for RSEs working in collaborative, code-intensive projects, that is just the tip of the iceberg. More detailed topics like branching, understanding merge conflicts and merging strategies are critical for managing code across a team of developers.

In this lesson we will explore branching and feature branch workflow, a popular method for collaborative development using Git, along with some intermediate Git features (merging, rebasing, cherry-picking) that can help streamline your development workflow and avoid common pitfalls in collaborative software development.

You’ll learn to:

• Understand the purpose and benefits of using Git branches in collaborative projects, especially the feature branch workflow.
• Compare Git merging strategies (fast-forward, 3-way merge, rebase, squash and merge) and understand when to use each.
• Gain familiarity with intermediate Git features, including cherry-picking, stashing, and resetting.

Pre-workshop requirements:

• Shell with Git version control tool installed
• Ability to navigate filesystem and run commands from within a shell
• Account on GitHub.com
• Understanding of Python syntax to be able to read and follow code examples

Thursday 29 October @ 13:30 - 15:00

Many researchers write code, install software libraries and share their scripts with collaborators. However, fewer people understand how packages are created, how dependencies are managed or how to make software easy for others to install and reuse.

Understanding packaging helps us move from writing code that works on our machine to developing software that others can reliably install, use, reproduce and contribute to.

In this session we will look into what software packaging entails and why should we care about packaging. In the practical part of this session, we will explore modern Python packaging and package management using uv, a fast Python package manager and project management tool that is rapidly becoming popular across the Python community.

You’ll learn to:

• Explain what software packaging is and why it is important for software reuse, reproducibility and sustainability.
• Describe the key components of a Python package and the role of package metadata, dependencies and documentation.
• Explain how package managers help manage dependencies and create reproducible software environments.
• Describe the difference between source distributions (sdists) and wheels.
• Use uv tool to prepare an installable Python package.

Pre-workshop requirements:

• Shell with Git version control tool installed and set up
• Ability to navigate filesystem and run commands from within a shell
• Ability to use basic Git commands from a shell
• Python version 3.8 or above installed (with pipand venv tools)
• Understanding of Python syntax to be able to read and follow code examples
• uv Python package and dependency management tool
• Code editor such as Visual Studio Code
• GitHub account
• Example code copied into your GitHub account

Monday 2 November @ 13:30 - 15:00

This session introduces the importance of documenting our software. We also discuss different types of software documentation aimed at various target audiences, including end users, developers, maintainers, administrators and contributors.

You’ll learn to:

• Describe the main types of software documentation and identify their primary audiences, including end users, developers, maintainers, contributors and system administrators.
• List components and audiences for code-level, software-level and project-level documentation for software projects.
• Use Diátaxis documentation framework to create different types of documentation according to the needs of the reader and the purpose the documentation serves.
• Generate and manage comprehensive software documentation using static documentation website generator tool MkDocs

Pre-workshop requirements:

• Shell with Git version control tool installed
• Ability to navigate filesystem and run commands from within a shell
• Python version 3.8 or above installed
• Understanding of Python syntax to be able to read and follow code examples
• Pip Python package installer
• Venv Python package to handle virtual environments
• Code editor such as Visual Studio Code

Monday 2 November @ 14:00 - 17:00

Does your visualisation tell a story? Data is continuously expanding and becoming more complex. On its own, data can feel daunting. However, through visualisation, we can transform raw numbers and text into captivating narratives. During this workshop, which is tailored for beginners, Annajiat Alim Rasel and Md Intekhabul Hafiz will assist you with the skills to use Python libraries to create a variety of visualisations, ranging from simple bar charts to intricate heatmaps.

Why Visualise Our Data?

• Simplify the Complex: Break down large and complicated datasets into visuals that are easy to grasp.
• Uncover Hidden Patterns: Identify trends, outliers, and correlations that might be missed in raw data.
• Enhance Understanding: Share insights in a more effective and intuitive manner.
• Make Data Accessible: Create visualisations that are inclusive, considering factors like color blindness.

What You'll Learn

• Fundamental Visualisation Techniques: Understand the basics of creating various types of charts, including bar charts, line charts, scatter plots, and more.
• Customising Your Visualisations: Discover how to tailor your visualisations to fit your specific needs, including colors, labels, and formatting.
• Effective Storytelling with Data: Learn how to use visualisation to communicate data-driven insights in a clear and engaging way.

By the end of this workshop, you'll be ready to use data visualization to tell stories with your data.

Pre-workshop requirements

A Google account for using Google Colab.

Tuesday 3 November @ 13:30 - 15:00

This lesson introduces key practices for effective coding and collaboration within research software projects. You will learn how to work together on code through structured approaches such as code review, understand common workflows and tools that support collaborative development, and explore the processes that help maintain code quality and team productivity. We will then take a practical look at how to carry out code reviews using GitHub, one of the most widely used platforms for collaborative software development.

You’ll learn to:

• Identify benefits of coding with others, including improved code quality and shared ownership.
• Recognise common collaborative practices such as code review, pair programming, and version control.
• Understand how early adoption of collaborative tools helps prepare for scaling up development.
• Apply the practical collaborative strategy code review in a software project.

Pre-workshop requirements:

• Account on GitHub.com
• Understanding of Python syntax to be able to read and follow code examples

Wednesday 4 November @ 13:30 - 15:00

Testing is a critical part of writing reliable, maintainable code — especially in collaborative or research environments where reproducibility and correctness are key. In this session, we will explore why testing matters, and introduce different levels of testing — from small, focused unit tests, to broader integration and system tests that check how components work together. We will also look at testing approaches such as regression testing (to ensure changes do not break existing behavior) and property-based testing (to test a wide range of inputs automatically). Finally, we will cover mocking, a technique used to isolate code during tests by simulating the behavior of external dependencies.

You’ll learn to:

• Describe what unit testing is and explain why it matters for software quality.
• Examine example code and identify where and how unit tests could be applied.
• Write a simple unit test for a function and integrate it into their project.
• Recognise common error/exception conditions in code and write tests that handle/expect such errors.
• Evaluate a test suite in terms of coverage.

Pre-workshop requirements:

• Shell with Git version control tool installed and the ability to navigate filesystem and run commands from within a shell
• Python version 3.8 or above installed
• Understanding of Python syntax to be able to read code examples
• Pip Python package installer
• Visual Studio Code installed (ideally the latest version)

Thursday 5 November @ 13:30 - 15:00

Doing tasks manually can be time-consuming, error-prone, and hard to reproduce, especially as the software project’s complexity grows. Using automation allows computers to handle repetitive, structured tasks reliably, quickly, and consistently, freeing up your time for more valuable and creative work.

Task automation is the process of using scripts or tools to perform tasks without manual intervention. In software development, automation helps streamline repetitive or complex tasks, such as running tests, building software, or processing data.

By automating these actions, you save time, reduce the chance of human error, and ensure that processes are reproducible and consistent. Automation also provides a clear, documented way to understand how things are run, making it easier for others to replicate or build upon your work.

You’ll learn to:

• Understand the concept of automation and its role in improving efficiency and consistency in software development.
• Learn the principles and benefits of Continuous Integration.
• Identify common tasks that can be automated within a CI pipeline, such as code compilation, testing, linting, and documentation generation.
• Recognise the importance of integrating code changes frequently to minimize conflicts and maintain a stable codebase.
• Explore how Continuous Integration can be extended to Continuous Delivery to automate the deployment of packages and applications.

Pre-workshop requirements:

• Shell with Git version control tool installed and the ability to navigate filesystem and run commands from within a shell
• Python version 3.8 or above installed
• Understanding of Python syntax to be able to read code examples
• Pip Python package installer
• Visual Studio Code installed (ideally the latest version)
• Account on GitHub.com

Friday 6 November @ 13:30 - 15:00

Containers have become a standard approach for developing, testing, deploying, and distributing modern software. A container approach packages an application together with its libraries, dependencies, and runtime environment into a single, portable virtual machine-like package (or container image) that runs consistently across different systems. Unlike virtual machines however, containers share the host operating system, making them lightweight, fast to start, and efficient to run. They simplify software deployment by ensuring that applications behave the same on a developer’s laptop, a testing environment, and in production, which reduces the common problem of “well, it works on my machine”.

You’ll learn to:

• Explain what containers are, how they work, and why they are useful for reproducible research software.
• Describe the key differences between containers and virtual machines.
• Verify a Podman installation and start a Podman machine on macOS or Windows.
• Pull container images from public registries and run containers using the Podman command-line interface.
• Manage the lifecycle of containers, including naming, starting, stopping, and removing them.
• Run a service container in detached mode, publish ports, and inspect its logs.
• Execute commands and open interactive shells inside running containers.
• Mount host directories into containers to share data between the host and the container.
• Search container registries from the command line and configure registry search on Linux.

Pre-workshop requirements:

Skill prerequisites for the practical activity:

• Ability to navigate filesystem and run commands from within a shell or terminal application

Software prerequisites:

• Shell or terminal application
• Podman, for running and managing containers
• A text editor you are familiar with

Friday 6 November @ 15:00 - 17:00

Quarto es una herramienta para crear documentos reproducibles que permite integrar texto, código, resultados y elementos visuales en un mismo flujo de trabajo. Esto nos permite generar reportes, presentaciones y otros productos de manera flexible y consistente. En este taller, introduciremos los principales conceptos y herramientas de Quarto. A través de actividades prácticas, aprenderemos a estructurar documentos, incorporar código y resultados, configurar su formato y generar distintos tipos de outputs.

Prerrequisitos: una versión reciente de Quarto (>= 1.10) y de Python o R (puedes elegir en qué lenguaje de programación trabajar durante el taller).