Teaching Supercomputing and SW Engineering Skills

Schliessen Icon
Kite Award 2024
NomineeLogo KITE Nominee


Our course at ETH Zurich teaches supercomputing and software engineering to science and engineering students. We use GPUs and Julia for physics-based simulations, a key part of modern science. Our students learn by doing, working on real numerical research projects with open-source tools and ETH resources. We communicate through Matrix/Element and GitHub, and assess students through exercises and projects, not exams. Our course is innovative, hands-on, and research-oriented.

In the midst of the pandemic, we designed and launched a new course to teach supercomputing and software engineering skills to science and engineering students at ETH Zurich. There is a good overview over the course on its website, which hosts most of the material. The course fills a gap in ETH’s curriculum regarding high-performance computing (HPC) on graphics processing units (GPUs) with a focus on physics-based simulations. The course focuses on challenging computations, which are playing an increasingly bigger role in modern science.

Our course exposes science and engineering students to leading-edge information technological advances and teaches them computational competencies (beyond solely GPU computing) that align very well with ETH’s teaching and digitalisation strategy. Advanced new programming languages, such as the Julia language, which we use, now make it possible for non-computer science students to design and code GPU-based HPC simulations without years of training, in a course that lasts just one semester. This is the largest contribution of this course to innovativeness, as defined in the KITE criteria.

We provide a practical approach to GPU and HPC computing, that is, the course is founded on project-, tooling- and research-based teaching to convey the designing, implementing and running of such applications. We want our students to experience ownership of the work (the code) they produced, the tools they learned and the projects they made during the course. To this end, we designed our course to be delivered in a hands-on way. Besides writing code, to us, hands-on also means that students need to learn and apply the skills and tools needed to successfully create and run simulations: software engineering tools (e.g., version control with git, GitHub, testing) and project management skills (e.g., writing documentation and reports, running simulations). In our view, all these skills are equally important if a student is to be successful as a computational scientist, thereby fulfilling the approach’s sustainability, as defined in the KITE criteria.

We pursue a research-oriented teaching and learning approach, both in the sense that we employ the taught methods and tools in our own research as well as in the sense that the students conduct their own numerical research projects during the course., The students likely benefit most when they are actively involved in carrying out the research process, instead of just learning research content. We implement this via project-based learning, which is a form of active learning in which students self-develop knowledge rather than having it presented by teachers. This contributes to the approach’s effectiveness, as defined in the KITE criteria.

Our course is fully open-source, with the entire content available on its website, and uses various online tools and resources, mostly ETH-powered, for immersive on-site and online participation. The lectures have a hybrid format. The first two lectures’ coding and exercises are hosted on an ETH JupyterHub instance that integrates with Moodle. The course’s subsequent hand-ins happen via GitHub, where the students host both their assignments and their two projects.

The hands-on and project-based teaching consists of six weekly assignments by students during part 1 of the course. This allows for personalised feedback and hones the skills needed to complete two larger projects, which form the course’s core. Project 1 is to solve thermal porous convection in three dimensions on multiple GPUs on the Piz Daint supercomputer at the Swiss National Supercomputing Centre (CSCS). In project 2, the students choose equations of their interest to solve using the methods and tools they have learned. The course also has active learning elements during the weekly three-hour class in the form of in-class coding. Further active learning support happens on an on-demand basis via the various digital channels in place during and between the lectures.

Innovative Elements

Students feel inspired and are motivated by the innovative solutions we provide in our course. The results include increased participation and above-average student satisfaction, as reflected in the course survey during the two first editions of the course (for evaluation results, see the Appendix). Student motivation is also very important and, as the semester advanced, many of our students began to prioritise the courserelated tasks, homework and projects over other courses. But perhaps most importantly, the innovative element in the course fosters autonomy among the students. They learn how to search for solutions, team up in some cases, and how to report on non-working issues by creating minimal examples that highlight their issues.

Our course innovates with new didactic approaches and methods, supporting new forms of knowledge transfers, interactions, independent learning and feedback. Our course teaches students leading-edge computational competencies required to perform state of the art numerical modelling studies. We implement new didactic approaches using a wide variety of digital tools that are available online, including JupyterHub, Moodle, Matrix/Element, GitHub and the Julia programming language. These tools are available to the broad ETH community, and some (such as JupyterHub or Moodle) are specifically designed for teaching. GitHub, the leading git hosting service, is currently standard in industry and in software development, and is starting to gain usage in scientific computing workflows thar require reproducibility, documentation and collaborative code development. In our course, we lever some advanced git and GitHub features, such as doing homework and projects fully git-based, using branches and pull-requests as workflow for personalised feedback. Further, we use GitHub Actions to teach and implement continuous integration and testing, and use it to deploy content such as the course website automatically on the web. Besides code-related tooling, we successfully introduced and now use the Matrix/Element staff/student chat platform to run our course-based chat service. The idea is to have a shared digital space where students can exchange about the course, the exercises and the project, together and with the teachers. Simultaneously, the teachers use the service on a private channel to coordinate about the course. After some weeks, we observe an interesting dynamic in the chat space as students begin to interact, answering their peers’ questions, fostering engagement and participation in a self-sustained way.

Another innovation of the course is the fully open-source content. The course material is freely accessible online; code, documentation and entire lectures can be deployed locally upon cloning the course’s GitHub repository, which provides a fully reproducible environment from a single source. The latter point is crucial for the teachers, as having a single source to maintain and edit allows for a highly efficient workflow and limits conflict by working collaboratively on the course content. Also, students can suggest changes or enhancements to the content directly by opening a pull-request on the main course repository, increasing their participation in the course.

The course content is designed to support new knowledge transfer types and foster independent learning. The general approach is to provide an incremental build-up of knowledge and competences throughout the course in order to provide to the students a (sub)set of skills that they can further apply in the two projects. We aimed for project-based learning models, since these are well received by students. The approach can be described as a form of active learning in which students self-develop knowledge rather than having it presented by teachers. The resulting project-based learnings further enhance student engagement.

Feedback is a key aspect in the learning process; students value it highly. We take this aspect seriously and decided for instance to limit the number of students in the course to about 25 so as to allow sufficient time to give all the students personalised feedback. The collaborative online tools such as Moodle, GitHub and the course chat space provide great opportunities to interact with students in a fully online but very personalised way.

How did you ensure (continues) feedback on student learning progress?

Ensuring continuous feedback on students’ learning progress is a challenging aspect to implement in a practical setting. Successfully providing feedback helps one to (i) ensure students’ progress and (ii) retain momentum and motivation. We implement continuous feedback for both initial assignments and during project work. This approach ensures that students are evaluated and receive feedback throughout the course. Students strongly value continuous feedback, as reflected in the surveys, and there was room for improvement, especially after the first edition of the course. The upside is increased student progress and satisfaction, while the downside is the high workload it causes for the teachers. We may further refine this aspect in the coming versions of the course, potentially transitioning toward more on-demand feedback, transferring the main actor locus from the teachers to the students. Students could for instance trigger feedback from some automated procedure when they need it, which may result in a lighter teacher workload.

Which elements of your project would you recommend to others?

The motivation that drives our course design relies on our idea to convey to (prospective) Master’s or Ph.D. students the necessary skills to perform computational science research with us or with other researchers in our field. These skills do not only include numerics but also other computational competencies, e.g. version control and testing, as well as skills such a project management and writing. Thus, teaching what we need prospective MSc and PhD students to know is one of the key aspects we broadly recommend to other teachers.

Further, the research-based learning approach we pursue involves students in carrying out the research process, a form of active learning. Thereby, students self-develop knowledge rather than having it presented by teachers, resulting in an effective approach that we can further recommend.

Allowing students to take ownership of their work is another very valuable component. Pushing them to develop their own codes from scratch helps to demystify key aspects and makes them feel responsible for and proud of the content they have created.

Finally, digital tools that can be used on an opt-in basis provide an interesting support platform. The classroom chat we are running on Matrix/Element is a successful example. The Q&A dynamic that develops there after the first weeks of the course provides a welcoming and safe environment for students and teachers to exchange information and content for the course, and allows for direct interaction if needed. Especially for code-based work, having the ability to format code snipped and exchange minimal working examples in a simple yet efficient way is very valuable. We strongly recommend it to other courses with similar needs.

Course Description

Solving Partial Differential Equations in Parallel on GPUs
This course aims to cover state-of-the-art methods in modern parallel computing on Graphics Processing Unit (GPU), supercomputing and code development with applications to natural sciences and engineering.
When quantitative assessment of physical processes governing natural and engineered systems relies on numerically solving differential equations, fast and accurate solutions require performant algorithms leveraging parallel hardware. The goal of this course is to offer a practical approach to solve systems of differential equations in parallel on GPUs using the Julia language. Julia combines high-level language conciseness to low-level language performance which enables efficient code development.
Completed BSc studies. Interest in and basic knowledge of numerics, applied mathematics, and physics/engineering sciences. Basic programming skills (in e.g. Matlab, Python, Julia); advanced programming skills are a plus.
graded semester performance

ETH Competence Framework