Christian Elmo | Digital Skills for the Modern PhD

Block 5: Advanced Scientific Python

Wed, 27 May 2026 00:00:00 +0000

It is better if you have attended blocks 1 to 4 before starting this one.

Introduction

Already comfortable with the basics from block 3 ? In Part 2 (Advanced), we go beyond syntax and focus on writing reliable, reusable code for real research projects.

What you’ll learn in Part 2 (Advanced):

Organizing code with functions, classes, modules, and simple packaging
Using virtual environments and dependency management for reproducibility
Working effectively with Jupyter/Marimo notebooks (structure, pitfalls, exports)
Data wrangling with pandas/polars and scientific workflows with SciPy
Plotting at scale and saving publication‑ready figures
Share devcontainer setups for consistent environments across team members
Time will be spent answering your specific questions and applying concepts to your research

By the end, you’ll have a robust, efficient workflow that scales from exploratory notebooks to reusable research code.

Program Outline

Code Organization and Reusability
- Functions and classes
- Modules and simple packaging
Environment and Dependency Management
- Virtual environments (conda/mamba)
- Managing dependencies with pip and YAML files.
Advanced Jupyter/Marimo Usage
- Notebook structure and best practices
- Exporting notebooks to scripts and reports
Data Wrangling with pandas/polars
- DataFrames and Series
- Data cleaning and transformation
Scientific Computing with SciPy
- Optimization
- ODE integration
- … and more
Plotting and Visualization
- Plotting with Matplotlib and Seaborn
- Saving publication‑ready figures
Collaborative Development with Devcontainers
- Setting up devcontainers for consistent environments
- Sharing setups with team members

Prerequisites

See block 3 for details on the prerequisites.

Block 4: Docker for Reproducible Research Environments

Tue, 12 May 2026 00:00:00 +0000

Containerization enables portable, isolated computational environments that improve the reproducibility, transparency, and longevity of research. This module introduces Docker for constructing, executing, and sharing environments that consistently reproduce analyses across machines and over time.

Learning outcomes

By the end of the session, participants will be able to:

Explain core concepts (images, containers, registries) and distinguish containers from virtual machines.
Author reproducible images with Dockerfile, including pinning versions and managing build context and caching.
Run containers with appropriate configuration (volumes, environment variables, ports, resource limits).
Package notebooks, command‑line tools, and dependencies for consistent execution and sharing.
Use Docker Compose for simple multi‑service setups where appropriate.
Publish and retrieve images from container registries (e.g., Docker Hub, GHCR) with tagged versions.
Apply containerization to research workflows for archiving, review, and publication.

Topics

Reproducible environments: motivation and principles
Images and layers; Dockerfile patterns (base images, multi‑stage builds, minimal images)
Data and state: bind mounts vs. volumes; handling large data
Interactive workflows: Jupyter in containers; connecting to GPUs/accelerators when available
Sharing and provenance: tags, digests, and registries
Good practices for research projects: directory structure, .dockerignore, licensing and metadata

Prerequisites

Basic command‑line familiarity; Git recommended for version control.
Administrative install permissions on your computer (Windows, macOS, or Linux).
Ability to install Docker Desktop or Docker Engine and run: docker --version and docker run hello-world.

Installation Instructions

A. Hardware requirements:

64-bit processor
8 GB system RAM recommended
At least 20 GB of free disk space
Enable hardware virtualization in BIOS/UEFI. For more information, see .

B. Software requirements:

Git, .
VS Code. Windows users should choose the System Installer version from the .

Make sure your computer meets these requirements before the session.

C. Docker Desktop

For this training session, we will install Docker through Docker Desktop. It provides both the Docker command-line tools and a graphical interface, which can be useful when learning.

Windows

We strongly recommend enabling the WSL 2 backend first. You can follow the official Microsoft guide .

Open PowerShell with administrator rights: right-click PowerShell and select “Run as administrator”.

Set WSL 2 as default:
```
wsl.exe --set-default-version 2
```
Install a version of Ubuntu (by default)
```
wsl.exe --install
```
During installation, you will be asked to provide a username and password for this virtual machine. Once installation is complete, you should be logged in to your Ubuntu virtual machine.

Download and install Docker Desktop for Windows from the . During the installation, make sure “Use WSL 2 instead of Hyper-V” is selected. At the end of the installation, you may need to restart your computer or sign out and sign back in. You do not need a Docker Hub account for this session, so you can skip the sign-in step.

macOS

Follow the official Docker Desktop for macOS installation instructions .

Linux (Ubuntu/Debian-based)

On Ubuntu, you can install Docker Desktop by following the official instructions .
If you install Docker Engine instead of Docker Desktop, follow the Linux post-installation steps so that you can run docker commands without sudo.

Whatever your operating system, you can check that Docker is installed by typing the following command into your terminal (PowerShell for Windows users):

docker run hello-world

Normally, you should see the following output:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
58dee6a49ef1: Pull complete
c3bdf82c34d1: Download complete
Digest: sha256:f9078146db2e05e794366b1bfe584a14ea6317f44027d10ef7dad65279026885
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

Format

The session combines a concise conceptual overview with guided, hands‑on exercises using research‑relevant examples. Templates are provided to facilitate adaptation to participants’ projects.

Block 3: Introduction to Scientific Python

Thu, 07 May 2026 00:00:00 +0000

It is better if you have attended blocks 1 and 2 before starting this one.

Introduction

You didn’t start a PhD to spend your days copying-pasting in Excel or manually renaming 200 files. You started it to do science — and Python is the tool that lets you focus on thinking, not clicking.

What you’ll learn in Block 3 is:

Core Python syntax: variables, types, and control flow
Essential data structures: lists, dicts, sets, and arrays
Working in notebooks and scripts (Jupyter vs. .py)
Reading/writing files and simple automation
Plotting basics with Matplotlib
First steps with NumPy and pandas/polars for data tasks

No coding background? No problem. We start from zero and build up the skills every researcher wishes they’d learned earlier.

Python isn’t just for programmers — it’s the Swiss army knife of modern research. Let’s make it your secret weapon.

A quick dive into Python

Python is a high-level, interpreted programming language known for its readability and versatility. It’s widely used in scientific computing, data analysis, machine learning, web development, and automation. Is is easy to learn for beginners yet powerful enough for experts, making it a popular choice across various domains.

# Variables and types
name = "Researcher"
age = 30
is_student = False
height = 1.75 # in meters
# Control flow
if age < 18:
 status = "Minor"
else:
 status = "Adult"
# Data structures
scores = [85, 90, 78, 92] # List
profile = {"name": name, "age": age, "status": status} # Dict
unique_ids = {101, 102, 103} # Set
import numpy as np
data = np.array([1, 2, 3, 4, 5])
# Functions
def greet(person):
 return f"Hello, {person}!"
print(greet(name))

Many interactive examples are available as Jupyter Notebooks on our teaching website .

Tutorial program

By the end of the session, participants will be able to:

Write basic Python scripts and Jupyter notebooks for data analysis.
Use core Python data structures and control flow to manipulate data.
Create basic plots using Matplotlib to visualize data.
Perform data manipulation tasks using NumPy and pandas/polars.

Prerequisites

Students must come with a laptop with administrative install permissions and a compatible OS (Windows, macOS, or Linux).
Install MiniForge, VSCode and GIT using our site instructions.

Block 2: Managing projects with Git

Mon, 04 May 2026 00:00:00 +0000

Training Scope (4h)

Using Git is essential for modern scientific work because it provides a reliable, transparent, and collaborative way to manage research code, data processing scripts, experiments, and even manuscripts. For doctoral students, Git ensures full traceability of every change, making it easy to reproduce results, compare different versions of an analysis, and avoid accidental data or code loss. It also enables seamless collaboration with supervisors and co-authors, allowing multiple people to work on the same project without conflicts. Beyond version tracking, Git supports open science practices by making it straightforward to publish research code on platforms like GitHub or GitLab, improving the credibility, reproducibility, and long-term impact of scientific work.

Learning Objectives

Understand versioning principles and adopt Git as the central tool for tracking code, data, and research documents.

Disclaimer:

This course focuses on practical Git usage for researchers. It does not cover advanced Git internals or server administration.

We will use VS Code’s integrated Git features for ease of use, but command-line equivalents will be provided.

Target Skills

Understand foundational concepts
- What is version control ?
- Local vs remote repositories
- Commits, branches, merges
Master essential Git commands using VS Code
- Initialize a repository
- Stage and commit changes
- Create and switch branches
- Push and pull from remote repositories
Collaborate on a project (GitHub, GitLab)
- Define remotes and clone repositories
- Define working strategies
- handle merge and conflicts
Track a scientific document
- Set up .gitignore for research files
- Revert to earlier states
Notion of advances features
- Tags and releases
- Pull requests
- GitHub/Gitlab CI/CD basics
- Git LFS for large files
Best practices
- Commit message conventions
- Structuring repositories properly
- Branching strategies (main/dev/feature)
- Backup and recovery strategies

Prerequisites, installation and configuration

Prerequisites

IMPORTANT: You need to be administrator on your computer to install Git and to run the configuration commands.

VS Code: Install Visual Studio Code (VS Code) as the IDE ( . Make sure to install the system installer version and not the ~~user installer~~.
GitHub account: Create an account on a Git hosting provider (GitHub, GitLab, Bitbucket) In this course, we will use GitHub as the remote hosting provider. If you don’t have an account yet, please sign up at and follow the instructions provided there.

Installation Instructions

Windows

Download and install Git for Windows from . Use Git Bash for command-line operations.

MacOS

In modern macOS versions, Git is included with the Xcode Command Line Tools. Install them by running xcode-select --install in the terminal. Alternatively, install Git via Homebrew with brew install git.

Linux(Debian based)

Open a terminal and run:

sudo apt update
sudo apt install git

Configuration Steps

Initial Git Setup

In order to set up Git for the first time, you need to configure your user name and email address. Open a terminal (git-bash on Windows) and run the following commands, replacing the placeholders with your actual information:

git config --global user.name "Your Name"
git config --global user.email "my-email@mail.com"

Fill in your GitHub email address to link your commits to your GitHub account.

SSH Key Generation and GitHub Configuration (Optional)

Note: If you use VS Code’s built-in Git authentication, you may skip this step.

If you plan to use SSH for authentication with GitHub (recommended for security and convenience), follow these steps:

Get your public rsa key by running the following command in your terminal (git-bash on Windows):
```
cat ~/.ssh/id_rsa.pub
```
If the file does not exist, generate a new SSH key pair with:
```
ssh-keygen -o
```
Follow the prompts to save the key (default location is fine) and set a passphrase if desired.
Copy the contents of the id_rsa.pub file to your clipboard.
Go to your GitHub account settings, navigate to “SSH and GPG keys”, and click “New SSH key”. Paste the contents of your public key into the “Key” field and give it a descriptive title.
Click “Add SSH key” to save.

My First Commit

To make your first commit using Git in VS Code, follow these steps:

Open VS Code and navigate to the folder where you want to create your Git repository.
Open the integrated terminal in VS Code (View > Terminal).
Initialize a new Git repository by running:
```
git init
```
Create a new file (e.g., README.md) and add some content to it.
Example: Creating README.md
In the terminal, run:
```
echo "# My First Git Repository" > README.md
```
In the Source Control panel (click the Source Control icon on the left sidebar), you should see the new file listed under “Changes”.
Stage the file by clicking the + icon next to it or by running:
```
git add README.md
```
Enter a commit message in the input box at the top of the Source Control panel (e.g., “Initial commit”) and click the checkmark icon to commit the changes, or run:
```
git commit -m "Initial commit"
```

Congratulations! You have made your first commit using Git in VS Code.

Block 1: An introduction to LaTeX for Academic Writing

Mon, 27 Apr 2026 00:00:00 +0000

Introduction

LaTeX is a robust typesetting system widely used for scholarly communication in the sciences, engineering, and the humanities. This session introduces the principles and disciplined practices that enable clear, consistent, and reproducible academic writing across theses, articles, and technical reports.

LaTeX vs. Word in Scientific Writing

LaTeX is a markup-based system designed for long, structured, and mathematically intensive documents. It separates content from formatting, ensuring stable layout, consistent references, and excellent typography—qualities that are especially valuable in PhD theses and scientific articles.

Word offers intuitive visual editing but can become fragile as documents grow, particularly when handling equations, figures, or complex formatting. While it remains convenient for quick drafting and broad collaboration, it lacks the reproducibility and structural reliability that LaTeX provides for large scientific manuscripts.

LaTeX separates content from presentation, allowing authors to focus on writing while ensuring consistent formatting. It excels at handling complex documents with features like automatic numbering, cross-referencing, bibliographies, and high-quality typesetting of mathematics.

A Simple LaTeX Document

A basic LaTeX document looks like this:

\documentclass{article}
\usepackage{amsmath}
\begin{document}
\title{An Introduction to LaTeX}
\author{Random PhD Student}
\date{\today}
\maketitle
\section{Introduction}
Wow \LaTeX is great for typesetting mathematics!
Here is an example of Einstein's famous equation:
\begin{equation}
E = mc^2
\end{equation}
\end{document}

Beautiful Mathematics

LaTeX was originally developed for high-quality typesetting of mathematical content, and it remains the gold standard in this area. Its math mode allows authors to create complex equations with ease, ensuring clarity and precision in scientific communication

\documentclass{article}
\usepackage{amsmath}
\begin{document}
\begin{equation}
\int_{a}^{b} f(x) \, dx = F(b) - F(a)
\end{equation}
\end{document}

Renders as:

$$ \int_{a}^{b} f(x) \, dx = F(b) - F(a) $$

Tutorial Program

By the end of the session, participants will be able to:

Write basic documents using LaTeX and compile them to PDF.
Structure documents using classes, packages, and a well‑defined preamble.
Compose mathematics, use figures, create tables, and use accurate cross‑referencing.
Manage bibliographies with BibTeX and apply journal or institutional citation styles.
Organize long projects using modular files and coherent directory layouts.
Compile reliably with modern engines and tools (e.g., latexmk) and diagnose common errors.
Manage your supervisors.

Emphasis is placed on reproducibility, separation of content and presentation, and maintainable project structure rather than ad‑hoc formatting. Basic command‑line familiarity is helpful but not required.

Prerequisites

Students must come with a laptop with administrative install permissions and a compatible OS (Windows, macOS, or Linux). These are required to install the LaTeX toolchain and editor extensions used in the session.
A LaTeX distribution that provides pdflatex and latexmk (e.g., , , or ).
Visual Studio Code (VS Code) as the IDE ( ); install the LaTeX Workshop extension ( ).
Git installed is recommended for version control examples ( ).

Platform notes

Windows

Install or and ensure pdflatex is available.
Install to enable latexmk and confirm perl is on your PATH.

MacOS

Install (or ) and ensure pdflatex/latexmk are available.

Linux

Install TeX Live from your package manager (see ) and ensure pdflatex/latexmk are available.

Verifications

To check PDFLaTeX installation, run the following commands in a terminal or command prompt: pdflatex -v

To check LaTeXmk installation, run the following commands in a terminal or command prompt: latexmk -v

On Windows, to check Perl installation (from Strawberry Perl), run the following commands in a terminal or command prompt: perl -v

Workflow

Thu, 01 Jan 2026 00:00:00 +0000

These workshops help PhD students build a simple, repeatable research workflow. You can follow the full sequence or pick only the modules you need.

We cover:

LaTeX for writing
Git for version control
Python for scripting and analysis
Docker for running projects the same way on any machine

Recommended sequence

Block 1:
Block 2:
Block 3:
Block 4:
Block 5:

You can enroll in any subset. This order works well because Python 2/2 assumes you’ve seen Python 1/2.

Pathways

You can:

Take only the sessions you need right now
Do the full sequence for a complete toolkit
Go step by step at your own pace

Intended audience

This series is for doctoral candidates who:

Are new to research computing tools
Want good habits early in the PhD
Want smoother writing, coding, collaboration, and reproducibility

Format and requirements

Format: Hands-on workshops with research-friendly examples
Level: Introductory (no prior experience required)
Requirements: A laptop with admin install permissions (Windows, macOS, or Linux). We’ll guide the setup during the sessions.

Not sure where to start? Contact Ludovic Charleux Christian Elmo and we’ll help you pick a path that fits your needs.