Parallel Computing

← All courses

A new course on high-performance computing in Julia, aimed at third-year ENSAI students who are comfortable in Python but new to Julia. The guiding idea: speed doesn’t come from a “magic” language but from understanding what the machine actually does — cost per operation, data movement, and sharing. Python is the familiar point of comparison; Julia is the test bench.

In preparation

This course is being developed and has not been taught yet. The materials linked below are early drafts and will evolve.

A single red thread runs through the course — estimating π by Monte-Carlo — carried from a plain sequential loop, to multithreading, to the GPU.

Modules

🔰 0 · Julia for Python users A short syntax bridge for Python programmers new to Julia: 1-based arrays, the end keyword, broadcasting with the dot, functions and structs, Unicode math. The onboarding before module 1 — no performance, no parallelism yet.
🧩 1 · Compilation & Types How Julia specialises code on types — why a pure Python loop takes ~1 s where Julia runs in milliseconds. Tools: @code_warntype, @btime; Python bytecode via dis.
🔀 2 · Multiple Dispatch vs OOP Julia's multiple dispatch as a language idea, contrasted with Python's OOP / singledispatch. A language module — no parallelism yet.
🧵 3 · Threads & Concurrency Concurrency first — @async/@sync to overlap I/O (fetching live market data on one core), then real multithreading with Threads.@spawn: Markov chains and a parallel Monte-Carlo π — including the race condition that silently corrupts a shared counter.
🧠 4 · Memory & Batching The processor spends its time waiting for memory. The cache cliff, locality (Julia is column-major — the opposite of numpy), and why batching is really a conversion of a memory-bound problem into a compute-bound one — measured on the CPU, before any GPU.
⚡ 5 · GPU Thousands of threads — provided you feed them. Coalescing, CPU vs GPU matmul, when the GPU starts paying off, and estimating π on the card (CUDA.jl; PyTorch CPU vs CUDA).

Approach

Each module pairs a common Python track (zero-install, in Jupyter/Colab — so nobody falls behind) with an optional Julia deep-dive (@btime, Threads.@spawn, the GPU). The teaching engine is comparing the numbers between the two: a Python loop at ~1 s next to a Julia loop in milliseconds makes the cost of abstraction concrete. Slides frame each session; the Pluto notebooks are live, executable demos.

Materials

The common track — zero install, runs in Colab. Every module’s benchmarks, in the language you already know.

1 — Compilation & Types 2 — Dispatch vs OOP 3 — Threads & Concurrency 4 — Memory & GPU

The same lessons as plain .jl files with #%% cells — for the VS Code Julia extension or the REPL, if you prefer that to Pluto.

0 — Julia for Python users 1 — Compilation & Types 2 — Dispatch vs OOP 3 — Threads & Concurrency 4 — Memory & GPU