test

Careful coding with copilots

Introduction

Fluorescence Extraction

ODE Simulation and Inference

Calibration

An LLM has been asked to create a Python package to analyse fluorescence microscopy images of cells expressing a three-member negative feedback loop (the so-called "repressilator") and to recover the governing parameters of the network for each cell. It has done a poor job: you are tasked with fixing its implementation.


Directing coding agents

Prompt design

Specifying a problem

Specifying a feature

Handling legacy research codebases

Modern coding agents will fix, implement and explain anything you ask, whether or not you ask for the right thing. Using issues, feature requests and codebases from real-world scientific software, this course teaches you how to direct coding agents effectively to leverage their power.


AI: Tools and Effective Practices

Tools and Effective Practices when using AI tools such as LLMs.


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

Practice and personal use

Rebasing and Squashing (Advanced)

Finding Bugs with git bisect (Advanced)

A Git Toolbox (Advanced)

Multiple Remotes and Self-Hosting (Advanced)

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. The final
modules are optional and marked "(Advanced)": newcomers can safely skip them
and return once the everyday Git workflow feels comfortable.


Packaging and Dependency Management

Packaging Python Projects

Making Packages

Reusing Packages

Sharing Packages

Virtual Environments

This course introduces the basics of packaging and dependency management in Python.
We introduce `venv` for virtual environments, and `pip` for package management and how to structure a modern Python package and publish it to PyPI.


Modern CMake

A first CMake project

Configuring the build

Subdirectories and the CMake language

Targets and libraries

Finding dependencies

Options and compiler warnings

Build presets

Reproducible dependencies

Testing with CTest

Installing and packaging

CMake is a widely used, cross-platform build system generator for C++ projects.
This course introduces the basics of CMake: writing CMakeLists.txt files to
configure and build executables and libraries, structuring larger projects across
subdirectories, finding and linking external dependencies, and using the CMake
language to make builds portable and reproducible. It then moves on to presets,
reproducible dependency management, testing with CTest, and installing and
packaging a library so it can be reused by other projects.


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

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 Workflow

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.


Continuous Integration

GitHub Actions

Code Coverage

Documenting your code

Documentation

Running checks before you commit and before you merge

Diagnosing failures and keeping the build fast

Build artifacts and approving a deployment

Trusting the code your workflows run

This course introduces continuous integration and how to set it up for a Python project using GitHub Actions, ending with documentation that publishes itself whenever the tests pass.


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.


Intro to Python

Running Python

Writing and running Python from an IDE

Variables and Types

Built-in Functions and Help

Lists

For Loops

Conditionals

Errors and Exceptions

Writing Functions

Variable Scope

This course introduces the basics of programming in Python, in two parts.
Part 1 covers the core language: running Python, variables and types, lists, loops, conditionals and reading errors.
Part 2 covers functions, exceptions, tuples and dictionaries, and then libraries for data analysis and visualization (NumPy, Matplotlib and pandas).


Introductory Courses

Introductory courses on programming languages.
