Structure and goals of the course

How This Course Is Organized

This course is designed as a guided path from “I have heard the term HPC” to “I can actually run and reason about parallel programs on a cluster.” The outline you saw is not just a table of contents. It is a learning sequence that builds layer by layer, with frequent returns to practice.

The early part of the course focuses on ideas and foundations. You start with what HPC is and why people use it, then move quickly into how modern computers are structured and how operating systems and Linux environments are used in practice. These first sections give you the vocabulary and mental model that you will use everywhere else in the course.

The middle part of the course concentrates on actual HPC systems and how to use them. You will learn what a cluster is, how jobs are scheduled, and how to submit and manage your own runs. You then move on to the main models of parallel programming, including shared memory, distributed memory, and GPUs, and you will see how these concepts map onto real hardware.

The later part of the course connects performance, software engineering, and practice. You will learn how to compile and optimize code, how to measure and improve performance, and how to use existing scientific libraries instead of reinventing them. You will also learn how to manage data, ensure reproducibility, debug and test parallel programs, and understand ethical and sustainability aspects of HPC usage.

The course ends by looking ahead to current trends and by guiding you through a final project that ties together the skills you have learned.

Learning Goals

The course has several concrete learning goals. By the end, you should not only know definitions but also be able to perform basic tasks on a real system and reason about performance.

The first goal is conceptual understanding. You should be able to explain what makes HPC different from ordinary desktop computing, describe the basic structure of modern processors and memory systems, and discuss why parallelism is both necessary and challenging. You will also be expected to understand, at a high level, the main forms of parallelism and the different hardware resources they use.

The second goal is practical system usage. You should be able to log in to a remote HPC cluster, navigate the Linux environment, manage files, and use modules or software stacks to select the right tools. You will learn to submit, monitor, and manage jobs through a scheduler, and to interpret basic scheduler feedback about resource usage and job state.

The third goal is programming and performance awareness. You will not become a specialist in every model, but you should be able to read and write small parallel examples using shared memory and distributed memory programming tools, and to understand GPU code examples at a conceptual level. You will learn what affects performance, such as memory access patterns and communication, and you will gain experience in measuring performance and interpreting simple profiling output.

The fourth goal is working with scientific software and data. You should become comfortable linking against numerical libraries, using precompiled applications on clusters, and managing input and output for large runs. You will practice using formats and strategies that are common in HPC work, including checkpointing and restarts.

The fifth goal is reproducibility and responsible usage. You will learn how to create and preserve software environments, for example using modules or containers, and how to document runs so that results can be reproduced. You will also learn how to size jobs appropriately, use resources efficiently, and understand the environmental and ethical context of HPC usage.

Finally, the capstone goal is integration. Through the final project you will design, run, and analyze a small but realistic HPC workflow. This consolidates the individual skills from earlier modules into a coherent practice.

Progression and Dependencies

The topics are arranged so that each section uses ideas from earlier sections without assuming prior experience in HPC.

You begin with the course overview, where you see what HPC is, why it matters, and what kinds of problems it solves. This contextual understanding prepares you for the more technical material that follows, and helps you recognize where HPC appears in real-world work.

You then study computer architecture, operating systems, and Linux. These sections provide the mental map of the hardware and software layers under your future programs. Concepts like CPUs, caches, memory, filesystems, and processes are introduced so that later discussions of performance and parallel programming have a clear foundation.

After that, you move into HPC-specific infrastructure and operation. You learn what an HPC cluster is, how its nodes and interconnects are organized, and how storage is arranged. This enables the introduction of job scheduling and resource management, where you interact with the system as an ordinary user, requesting resources and running programs through a scheduler.

Parallel computing concepts appear only after you have a basic sense of the hardware and the cluster environment. In this section you meet the core ideas of parallel work, such as different types of parallelism and scaling, without yet focusing on any particular programming tool. These concepts then feed directly into the programming sections.

Shared memory and distributed memory programming are treated in separate sections, followed by hybrid and accelerator programming. Each builds on the abstract concepts of parallelism and on your understanding of cluster organization and node-level resources. GPU topics come after CPU-based parallel models so that you can recognize the similarities and differences in how parallelism is expressed.

Compiler and build-system topics sit at the boundary between programming and performance analysis. They give you the practical ability to produce optimized executables and to manage more complex build processes, which is essential when you start measuring and tuning performance in the performance analysis section.

The remaining sections about numerical libraries, data management, reproducibility, debugging, and testing rely on all earlier material. They show you how to work with realistic software stacks, large data, and nontrivial programs in a way that is robust and maintainable. The concluding sections on practice, ethics, and future trends pull the technical content together into a bigger picture, and the final project gives you a structured context where all these abilities are used together.

Balance of Theory and Practice

The course alternates between conceptual material and hands-on work. When you learn about a new idea, you will usually follow it with a practical task where you apply it on a real or simulated system.

In the architecture and Linux sections, you will connect theoretical ideas like memory hierarchy to direct experiments, such as observing the effect of accessing data in different patterns or timing simple programs compiled with different optimization settings.

In the cluster and scheduling sections, you will practice concrete commands to log in, move files, and submit jobs. You will learn not only the syntax but also how to interpret job states, understand scheduler messages, and adjust job parameters based on feedback.

In the programming sections, short illustrative codes will show how concepts like task parallelism, data parallelism, and communication patterns appear in actual source files. You will compile, run, and inspect these codes so that you can connect performance discussions to specific pieces of code.

Performance analysis and optimization combine this practice with more abstract considerations. You will design small experiments, measure key quantities such as runtime and speedup, and think about how changes in code structure or resource allocation influence those measurements.

Throughout, the course treats HPC as an applied discipline. Theoretical ideas about parallelism, scaling, and hardware are always tied to their impact on your ability to run computations faster, more reliably, or more cheaply.

Expected Background and Workload

The course is aimed at absolute beginners in HPC. You are not expected to have used a cluster before, and you are not required to have deep knowledge of computer architecture or performance tuning.

You should, however, have basic programming experience in at least one compiled or scripting language. The examples in the course will refer to conventional languages that are common in HPC environments, but you do not need to be expert in them to follow the core ideas. The focus is on principles and patterns that apply across languages.

Some prior familiarity with the command line is helpful, but the course includes a dedicated section on basic Linux usage. You will gradually build confidence with commands and concepts as you go. The early Linux content is intentionally gentle, since it is a key skill for everything else in the course.

In terms of workload, you can expect regular short exercises that mirror the progression of topics. Early exercises focus on navigation, compilation, and simple runs. Later ones involve designing small parallel experiments, measuring performance, and exploring libraries or tools. The final project requires more sustained effort but is structured so that each part draws on earlier exercises.

How Assessment Aligns With Goals

Assessment in this course is designed to test practical competence and understanding rather than memorization of details.

You will be evaluated on your ability to perform typical HPC tasks. These include logging in to a cluster, organizing directories and files, submitting and monitoring jobs, using modules or similar environment tools, compiling code with different configurations, and running performance experiments.

You will also be assessed on your understanding of fundamental HPC concepts such as types of parallelism, why scaling is limited, and how memory and communication affect performance. Questions and tasks will emphasize reasoning about trade offs, for example when choosing between different forms of parallelism or between different resource requests for a job.

The final project plays a central role in assessment. It synthesizes earlier skills into a coherent narrative: you will define a computational goal, set up and run an application or set of experiments, measure outcomes, and interpret them in light of HPC concepts. Written documentation of your workflow and results, including how to reproduce them, forms an important part of the project.

How to Use This Course Effectively

To get the most from the course, it is important to follow the intended sequence rather than skipping directly to advanced topics. Early sections supply the context needed to make sense of later material, especially performance analysis and debugging.

When you encounter new commands, tools, or library calls, try them yourself on the provided systems or examples instead of only reading the description. Repeating small tasks, such as submitting a simple job with slightly different parameters, will make more advanced workflows feel natural later.

As you progress, keep notes on configuration choices, commands you run, and environment details. This habit supports both reproducibility and learning. Many later topics in the course, including reproducible workflows and performance reports, will benefit directly from these notes.

Finally, use the structure of the course as a guide to your own mental model of HPC. Each major section corresponds to a core aspect of practical high performance computing: architecture, environment, parallel programming, performance, software and data, and responsible usage. Treat these as the main pillars that your future HPC work will rest on, and let the detailed sections fill in each pillar with concrete skills and examples.