Instructor Guide: Overview

Introduction to Fortran Programming: The Language of Supercomputers is designed to be taught as well as self-studied. This guide collects the material an instructor needs: syllabi, per-chapter teaching notes and discussion guides, an exam bank, and grading rubrics. This page explains the book's design so you can adapt it to your course.

What this book is (and isn't)

It is a from-scratch, comprehensive introduction to Modern Fortran (2018 baseline, gfortran) for students who already program in some language. It teaches the language, the numerical methods it is used for, its performance model, and parallel programming — all the way to MPI and GPUs — anchored by one running project a student builds across the whole book: a 2D heat-equation solver.

It is not a numerical-analysis text (the mathematics is introduced only as the computation needs it, in Part V) and not a reference manual (Metcalf/Reid/Cohen fills that role). It assumes students can program; it does not assume they know Fortran, HPC, compilers, or parallelism.

Courses this book can support

  • A three-semester sequence in scientific computing (see syllabus-3-semester.md): Semester 1, fundamentals and modern features (Parts I–II); Semester 2, ecosystem, legacy, numerical methods, and data (Parts III–VI); Semester 3, performance, parallelism, and real-world practice (Parts VII–IX, with Part X as a coda).
  • A one-semester "Programming for Scientists/Engineers" or "Intro to HPC" (see syllabus-1-semester.md): Parts I–II in full, then selected chapters from Parts V and VII–VIII.
  • A "second language" course for CS students, emphasizing Parts I–III and Part IV (how a real, long-lived language handles legacy and interoperability).
  • Self-paced professional study (see syllabus-self-paced.md), following one of the book's four reading tracks (🔬 Scientist, 📖 Standard, 🔧 Legacy, ⚡ HPC).

How each chapter is structured (and how to use it)

Each chapter folder contains seven student-facing files plus code:

  • index.md — the chapter. Assign as reading; the numbered sections map cleanly to lectures.
  • exercises.md — 25–35 graded problems (⭐/⭐⭐/⭐⭐⭐), spanning type-compile-run, port-from-Python, find-the-bug, modernize-this-F77, design-it (extend the solver), and back-of-envelope. Solutions to daggered (†) and odd problems are in appendices/answers-to-selected.md; keep the even, un-daggered problems for graded homework.
  • quiz.md — ~20 self-check questions with an answer key; good as a reading check or a warm-up.
  • case-study-01.md / case-study-02.md — two worked scenarios (CS-01 analyzes existing code; CS-02 builds/optimizes one). Excellent for lab sessions or as scaffolded projects.
  • key-takeaways.md — a one-page reference; hand out as a study aid.
  • further-reading.md — annotated pointers for curious students.
  • code/ — every in-chapter example as a compilable .f90 (plus .py/.c where relevant). The book's policy is that no code is executed during authoring — every "expected output" is hand-computed — so a valuable in-class exercise is simply to compile and run the examples and confirm the book's predictions.

Per-chapter teaching notes (chapter-notes/chNN-notes.md) and discussion guides (discussion-guides/chNN-discussion.md) give you, for each chapter, the key ideas to emphasize, the misconceptions to preempt, a live-coding demo, a class-time budget, and ready-to-use discussion prompts and group activities.

The running project as the spine of assessment

The heat-equation solver (specified in each chapter's Project Checkpoint, complete code in Appendix I) is the natural backbone of a course. Consider assessing it in three milestones aligned to the parts:

  1. Serial solver (after Part V / Chapter 24): a correct, modular solver validated against the analytical steady state.
  2. Instrumented and optimized (after Part VII): profiled, tuned, and measurably faster.
  3. Parallel capstone (after Part IX / Chapter 38): parallelized (OpenMP, coarrays, or MPI), validated, and written up as a short paper.

The rubrics/ folder provides a project rubric, a participation rubric, and a problem-set rubric.

A note on the toolchain

Students need gfortran (>= 10), and — for the later parts — an OpenMP-capable compiler (gfortran has it), coarray support (-fcoarray with OpenCoarrays), and an MPI implementation (OpenMPI or MPICH). Appendix C covers installation on all platforms. For classes without cluster access, every parallel example runs on a laptop's own cores (and MPI runs as multiple local processes), so no supercomputer is required; a shared Linux VM or a container image is a convenient way to standardize the environment.