Essential Maths

HPC Introduction

Intro to C++

Shell basics, IDE setup, and core C++ concepts.

Intro to Python

Python fundamentals for scripting and data work.

Supercomputing Fundamentals

Version Control with Git

Version control with Git for day-to-day work.

Cloud Computing

Moving applications and data into the cloud.

Collaboration with GitHub

Using GitHub for collaborative development.

Computer Simulations and Parallel Architectures

Computer simulations and the machines that run them.

Continuous Integration

Continuous integration with GitHub-based workflows.

Docker Basics

Docker basics for containers and reproducibility.

Linear Algebra

Solving systems of equations with matrices.

MPI Parallel Programming

An introduction to message-passing parallel programming with MPI.

ODE Solvers and Numerical Methods

OpenMP Parallel Programming

An introduction to shared-memory parallel programming with OpenMP.

Optimisation

Packaging and Dependency Management in Python

Packaging and dependency management in Python.

Parallel Computing Concepts

PyBaMM Foundations

Scalability and Profiling

Scalability and profiling on parallel systems.

Snakemake Workflows

Software Architecture in C++

Procedural, functional, and object orientated programming in C++.

Software Architecture in Python

Procedural, functional, and object orientated programming in Python.

Software Testing in Python

Writing and organising automated tests in Python.

Sparse Linear Algebra

PyBaMM Developer

A more detailed look at how PyBaMM models are built.

test

Procedural Programming

Variables

Functions

Containers

Arrays

Procedural Programming is based around the idea that code should be structured
into a sequence of **procedures** that operate on data. This course will
introduce you to the basics of procedural programming in either Python or C++.


Object-Orientated Programming

Classes

Inheritance and Composition

Polymorphism

The Object Oriented Paradigm builds upon the Procedural Paradigm, but builds code around data.
This course will introduce you to the basics of Object Oriented Programming in either Python or C++.


Functional Programming

State and Side Effects

Recursion

Higher-Order Functions

Side Effects

Functional Programming is based around the idea that programs are constructed
by applying and composing/chaining **functions**. This course will introduce
you to the basics of functional programming in either Python or C++.


Software Architecture and Design

Programming design concepts and patterns, such as procedural, object-orientated, functional, generic. Covers data structures, memory allocation, ownership.


The Bash shell

Introducing the Shell

Files and Directories

Creating Things

Pipes and Filters

Shell Scripts

Loops

The Bash shell is a command-line interface used in Unix-based operating systems
such as Linux and macOS. This course will introduce you to the basics of using
the Bash shell.


Version Control

Automated Version Control

Setting Up Git

Creating a Repository

Tracking Changes

Exploring History

Remote Repositories

Branches

Ignoring Things

This course introduces the basics of version control using the Git version control system.
We will learn how to setup Git, and use it to track changes in our code.


Packaging and Dependency Management

Packaging Python Projects

Making Packages

Reusing Packages

Sharing Packages

Virtual Environments

Introduction to CMake

This course introduces the basics of packaging and dependency management in Python and C++.
For Python, we introduce `venv` for virtual envronments, and `pip` for package management and how to structure a modern Python package and publish it to PyPI.
For C++, we introduce the CMake build system and how use it to manage dependencies and the build process.


Best Practices

Code Style

Linters

This course covers how to style your Python code, and use linters to enforce a consistent style and highlight any code that can lead to commonly encountered bugs or problems.


IDEs

VSCode

Integrated Development Environments (IDEs) provide programmers with a complete development environment to
write, edit, debug, and deploy their code. This course introduces the popular VSCode IDE, both for Python
and C++ development.


Testing

Automated Testing

Diagnosing Issues

Scaling Up Unit Testing

Testable Code and Fixtures

Using Mocks in Tests

This course introduces the basics of automated testing and debugging in Python, using the Pytest framework.


Containerisation with Docker

Introduction

Setup

Docker Command Line

Cleaning Up Containers

Running-containers

Finding Containers on Docker Hub

Creating Containers

More Complex Containers

Examples

Using Docker with Github Actions

Using Docker with Jekyll

Reproducibility and Granularity

This course aims to introduce the use of Docker containers with the goal of
using them to effect reproducible computational environments.


Snakemake

Basics: An example workflow

Advanced: Decorating

Additional features

Short tutorial

This course introduces the text-based workflow system Snakemake. Snakemake is a general-purpose workflow management system for any discipline.


Technology and Tooling

Basic tools like bash, version control, containers, IDEs, and snakemake.


Collaboration on GitHub

Git Refresher

Collaborative Worklow

Issue Management

This course will show you how to use Git for effective collaboration with others
using the GitHub platform. After completion of the course, you will be able to
contribute to projects on GitHub, including opening issues and pull requests.


GitHub Actions

Code Coverage

Documentation

This course introduces the concept of continuous integration and how to set it up for a Python project using GitHub Actions.


Software Project Management

Courses on software project management such as on collaborative programming and continuous integration.


Introduction to Supercomputing

Understanding Supercomputing

Supercomputing World

Image Sharpening using HPC

An introduction to supercomputing, including why we need them and how they are used.


Parallel and Distributed Computers

Parallelism in Everyday Computers

Connecting Multiple Computers

Comparing the Two Approaches

Shared vs Distributed Hello World

This module introduces parallel and distributed computation, looking at how our own computers work, and ways of
combining and making use of the computing power of many computational resources such as computer processors and
other machines.


Parallel Computing

Introduction to Parallel Computing

Parallel Computing Programming

Parallel Computing Performance

Parallelising Mandelbrot Set Generation

This module covers how supercomputers are programmed to make use of computational resources in parallel to perform
calculations more quickly.


Computer Simulations

Traffic Simulation Performance

Introduction to Computer Simulations

Weather Simulations

Towards the Future

This module introduces computer simulations, using a number of examples, which are used to explore the behaviour
of a real-world system represented as a mathematical model.


Setting Up a Training Slurm Cluster on AWS

How to set up a minimal Slurm cluster

A short guide to setting up a Slurm training cluster on AWS with Flight Solo.


Introduction to High Performance Computing

Why Use a Cluster?

Connecting to Remote HPC systems

Exploring Remote Resources

Introduction to Job Scheduling

Accessing Software via Modules

Transferring Files with Remote Computers

Running a parallel job

Using Resources Effectively

Using Shared Resources Responsibly

An introduction to high-performance computing (HPC), covering connecting to HPC resources and the slurm job scheduler.


Introduction to Parallelism

This session introduces the basics of parallelisation and parallel programming, covering shared and distributed memory, different parallel paradigms, and the distinctions between data parallelism and message passing.


HPC Scalability Profiling

Understanding Code Scalability

Scalability Profiling

This session introduces the concept of scalability and how to profile the scalability of your code with an increasing number of cores.


Introduction to the Message Passing Interface

Communicating Data in MPI

Point-to-Point Communication

Collective Communication

Non-blocking Communication

Derived Data Types

Porting Serial Code to MPI

Optimising MPI Applications

Common Communication Patterns

Advanced Communication Techniques

This session introduces the Message Passing Interface (MPI), teaching trainees how to use the MPI API for compiling and running applications across multiple processes. It covers point-to-point and collective communication, non-blocking functions, and handling non-contiguous memory with derived data types. Attendees will practice converting serial code to parallel, understanding scaling performance, and using profilers to optimise MPI applications.


Parallel Programming with OpenMP

Introduction to OpenMP

Parallelisation with OpenMP

Synchronisation and Race Conditions

Introduction to Hybrid Parallelism

This session covers the fundamentals of OpenMP, including its API, compilation, and execution. Participants will learn to parallelise their programs using OpenMP's pragma directives, manage threads, and control variable scoping and loop scheduling. The session also addresses thread synchronization, race conditions, and the use of hybrid parallelism with OpenMP and MPI.


High Performance Computing

An introduction to high-performance computing (HPC), covering connecting to HPC resources, job schedulers (also known as batch systems), and techniques for determining the scalability of code on HPC resources.


Running Python

Variables and Types

Writing and running Python from an IDE

This course introduces the basics of programming in Python.
We will learn how to run Python code, and how to use variables, functions, and control flow.
We will also learn how to use Python for data analysis and visualization.


Introductory Courses

Introductory courses on programming languages.
