Teaching

Philosophy

I teach computation as a tool for understanding, not an end in itself. Students leave my courses with transferable skills: version control, reproducible environments, literate analysis, and the confidence to modify code they did not write. Two sources shape the approach.

First, the Carpentries pedagogy: live coding at the pace of the slowest participant, formative assessment through minute cards and coloured sticky-notes, deliberate management of cognitive load. I have been a certified instructor since 2019 and served on the HPC-Carpentry steering council (2022-2023) and the Instructor Development Committee (2020-2021). The core insight is that teaching a computational skill is inseparable from modeling the process of acquiring it; I show students my own errors and recovery paths, not just finished code.

Second, working through McElreath’s Statistical Rethinking reshaped how I design courses. Bayesian reasoning treats student understanding as a prior to be updated by evidence, not overwritten by instruction. Concretely that means I build assessments around iteration: short, frequent, low- stakes checks with explicit feedback, followed by revised submissions. Students rebuild their mental model in public, and so do I.

Assessment and curriculum design

I favour visible constraints over hidden expectations. A rubric or checklist in front of the learner, not a “we’ll know it when we see it” standard in the instructor’s head. For computational courses this means autograded tests (Hedgehog, pytest) on well-specified scaffolds, paired with written rationale requirements that make the reasoning assessable alongside the correctness.

For curriculum design I follow the Diataxis model: tutorials teach a skill, how-tos solve a task, reference explains the system, explanations deepen understanding. The four modes get confused in most scientific computing courses (and most software docs), and untangling them is one of the highest-leverage moves a course designer can make.

Mentoring philosophy

Mentorship is supervised autonomy. I give students real problems with real stakes (shipping to a package used by others, reviewing a pull request with a deadline, responding to a reviewer request) and the scaffolding to own the decisions. GSoC 2021-2024 taught me that the failure mode is either too little structure - students drift - or too much structure - students never learn to decide. The calibration lives in weekly one-on-ones with concrete next-step commitments that the student, not the mentor, articulates.

I also believe in showing the process. When I review code, I leave questions, not verdicts. When I propose a design, I walk through the alternatives I rejected and why. Students learn to reproduce that reasoning, not just its output.

Courses I am prepared to teach

The following lists the courses I could deliver as an independent instructor on short notice. Each is grounded in either my own research or in code / curricula I have already built for workshops and short courses.

Undergraduate

• Scientific Computing I (CS or Physics, second year). Numerical methods, floating-point arithmetic, linear systems, ODEs, basic optimization. Implementations in Python and C++ with explicit attention to performance and numerical stability. Assessment: weekly problem sets autograded against reference solutions, plus a capstone where students implement a published algorithm from scratch.
• Introduction to Computational Chemistry (third year). Classical MD, empirical potentials, basic electronic structure (Hartree-Fock, DFT), transition state theory. Hands-on labs in ASE and one quantum chemistry code.
• Data Analysis for the Physical Sciences (second / third year). Regression, hypothesis testing, Bayesian inference with brms / Stan, bootstrap and jackknife, basic ML. R and Python, emphasis on honest uncertainty reporting.
• Scientific Software Engineering (CS, third / fourth year). Version control, testing, packaging, CI/CD, reproducible environments with pixi / Nix, performance benchmarking. Capstone: a publishable package with CI, tests, docs, and a registered DOI.

Graduate

• Gaussian Processes and Surrogate Modeling (first-year graduate). GP regression, kernel design, active learning, dimensionality reduction, applications to PDE surrogates and saddle point searches. Connects to my GP acceleration thread.
• Computational Methods for Reaction Mechanisms (second-year graduate). NEB and its variants, dimer and MMF methods, transition state theory, enhanced sampling (metadynamics, milestoning). Connects to the transition state methods thread; uses eOn as the lab framework.
• Bayesian Methods in Computational Science (graduate elective). Hierarchical models for algorithm benchmarking, model comparison, posterior predictive checks, inference for stochastic simulations. Connects to the Bayesian statistics thread.
• Topics in Machine-Learned Potentials (graduate seminar). Literature- driven reading group on MLIPs (Behler-Parrinello, SchNet, NequIP, MACE, PET-MAD, foundation potentials), plus hands-on integration with atomistic simulation engines. Connects to the ML atomistic thread.
• Research Software Engineering for Scientists (graduate / postdoc). The one course that I wish had existed when I started. Git workflows, language interop (f2py, pybind11, Cython), build systems (meson, CMake, pixi), packaging for conda-forge and PyPI, documentation (Diataxis), CI/CD, code review, contributing to upstream. Direct continuation of my Carpentries and Code in Place teaching.

Short courses and workshops (ready to deliver)

• Nix on HPC (one-day tutorial, delivered at CarpentryCon 2020 and as internal workshops at the University of Iceland).
• Reproducible Environments with pixi (half-day tutorial, used in the Scientific Software Interoperability workflows).
• f2py and Fortran-Python interop (half-day tutorial).
• Python packaging end-to-end (half-day; basis of the Python Dissemination Workbench).
• eOn + PET-MAD reaction path tutorial (half-day hands-on, as in the Atomistic Cookbook recipe).

University Courses

HBV505M: Software Quality Management (University of Iceland, Fall 2024)

Supervisory teacher. Metrics and models for managing software quality, QA standards, quality assurance in agile development, progress control.

REI505M: Machine Learning (University of Iceland, Fall 2023)

Assistant teacher. Introductory course on supervised and unsupervised learning, data preprocessing, model evaluation, deep learning, cluster analysis, reinforcement learning.

Statistical Inference for Biology (The Jackson Laboratory, May 2022)

Instructor for an R workshop on frequentist statistical inference for experimental design and analysis.

CS106A: Code in Place (Stanford University, 2020 and 2021)

Section leader (TA) for the online COVID-era version of Stanford’s introductory CS course. In 2021, returned as a teaching mentor for first-time section leaders. Also delivered a Nix workshop for the SL cohort.

On-boarding for Code in Place | Code In Place 2021 SL Workshop | Wrapping Up Code in Place 2021

Invited Instruction

Web Development for Physicists (IOP, June 2021)

Invited instructor. Overview of SSGs, referencing frameworks, and practical web tools for working physicists. Supplement

C++ Part 2: Libraries and Simulations (IOP, April 2021)

Invited instructor. Intensive workshop on augmenting C++ code with Python bindings and CMake-based build automation with CI. Supplement

Carpentries Workshops

Certified Carpentry instructor since 2019. R Novice Inflammation lesson maintainer. HPC-Carpentry steering council member (2022-2023).

Educational Materials

Python Dissemination Workbench

A structured lesson on Python packaging, submitted to the Carpentries Lab (JOSE). Covers environment management, project structure, testing, and distribution in roughly two hours.

Site | GitHub

eOn + PET-MAD NEB Cookbook Recipe

Tutorial recipe in the Atomistic Cookbook demonstrating the Hessian-enhanced CI-NEB method with PET-MAD machine-learned potentials. This connects the transition state methods thread to a hands-on, reproducible workflow.

RSE and reproducibility tutorials (blog)

Lesson-style posts on rgoswami.me aimed at students and researchers. They grew out of workshops, office hours, and questions that kept recurring. Grouped by target audience:

• Nix for scientists and HPC users: CarpentryCon introduction to Nix; Local Nix without root; Nix, channels, and the NUR.
• Python packaging with Nix: mach-nix and Niv for Python.
• R packaging with Nix: R x Nix Nexus series (non-CRAN R packages with Nix).
• Node development with Nix: Nix shells for Node projects.
• Research data workflows: Storing data with DVC and OneDrive (data versioning on institutional OneDrive); Reproducible research series.

Grants for Teaching and Mentoring

• NumFOCUS Small Development Grant (2020): d-SEAMS documentation and training materials
• Google Summer of Code (2023): Mentoring PySEAMS Python bindings under PSF
• Google Season of Docs (2020-2021): SymEngine documentation project
• NumFOCUS SDGs (2022, 2023): LFortran SciPy compilation
• Google Season of Docs (2022): LFortran documentation