The University HPC Lab-Module Authoring Playbook

Description

What is the The University HPC Lab-Module Authoring course about?

Stand up a research-computing teaching module your students can submit, peer-review, and defend inside one semester. A student finishes a parallel computing assignment, brings you a speedup curve, and asks which result belongs in the writeup. You can answer it for that student in office hours. You cannot answer it twenty times a week without a rubric, a reproducibility checklist, and a.

What does the The University HPC Lab-Module Authoring cover on the University HPC Lab-Module Authoring Playbook?

Why this course?

What do you take away from the The University HPC Lab-Module Authoring course?

One complete HPC teaching module authored, with module brief, rubric, and reproducibility checklist. A peer-review worksheet students fill in for each other before submission, cutting first-pass supervision work. A marker calibration sheet so co-markers grade consistently across submissions. A cluster-access policy template covering queue limits, walltime caps, and abuse handling for the module's duration. A viva script that lets the student defend.

What you get with this course?

All 12 written modules in the Art of Service learning environment. Module brief template, rubric template, reproducibility checklist, peer-review worksheet, cluster-access policy template, scheduler script template, viva script, retrospective template. Worked examples for a SLURM, a PBS, and an LSF environment so the templates run on whichever scheduler your cluster uses. The hand-built implementation playbook tailored to your department's cluster size, scheduler.

What you will have in hand by Day 1, Week 1, Month 1?

Within 24 hours, your account in the learning environment is provisioned and the tailored implementation playbook is delivered alongside it. Week 1: module brief, rubric, reproducibility checklist drafted. Week 2: peer-review worksheet, cluster-access policy, scheduler script template in place. Week 3: submission packaging, write-up structure, marker calibration session run. Week 4: viva script and moderation policy authored. Week 5: retrospective template installed.

What does the The University HPC Lab-Module Authoring cover on before and after?

Supervision happens one student at a time in office hours, every assignment is marked from scratch, three errors recur across cohorts, and the module is rewritten every year because the prior year's structure was not preserved. Students submit against a known rubric they have already peer-reviewed each other against, markers calibrate in one hour, vivas run from a script, appeals are resolved.

What happens if you do not address this?

Without a written module with a rubric and a peer-review step, the next cohort consumes the same supervision time as the last, the same errors recur, and the cluster runs hot during the same two weeks of term. The teaching load grows with student count rather than scaling.

Closely related courses: The University Early Careers Program Operator Playbook.

More answers: what you get with every course, refund policy, all help answers.

A focused course, tailored for you

The University HPC Lab-Module Authoring Playbook

Stand up a research-computing teaching module your students can submit, peer-review, and defend inside one semester.

A student finishes a parallel computing assignment, brings you a speedup curve, and asks which result belongs in the writeup. You can answer it for that student in office hours. You cannot answer it twenty times a week without a rubric, a reproducibility checklist, and a peer-review structure that does the first pass before anything reaches you.

$199 one-time

Tailored to your situation. Access within 24 hours. 30-day money-back.

Includes a hand-built implementation playbook delivered alongside course access, generated for your specific situation.

Why this course

Research computing teaching at a university sits across three jobs at once. You hold a supervisory load that scales with student count. You administer cluster access, queue policies, and a scheduler that nobody else in the faculty wants to learn. You author a curriculum that has to teach reproducible parallel work without consuming your week in one-on-ones. The gap that quietly costs you the most time is the absence of a written module with a rubric students mark each other against before submission. Without it, every student email is a reset, every viva is from scratch, and the same five errors show up term after term. This course fixes the gap by giving you a single, defensible teaching module you can drop into the next semester catalogue.

What you walk away with

One complete HPC teaching module authored, with module brief, rubric, and reproducibility checklist.
A peer-review worksheet students fill in for each other before submission, cutting first-pass supervision work.
A marker calibration sheet so co-markers grade consistently across submissions.
A cluster-access policy template covering queue limits, walltime caps, and abuse handling for the module's duration.
A viva script that lets the student defend their result against the rubric, not against the marker's memory.

The 12 modules

Module 1. The teaching module brief

Write the one-page brief that defines the module's learning outcome, the cluster resources students will consume, the deliverable, and the assessment weight. The brief is what the department signs off on and what students are referred back to whenever scope drift surfaces. The course walks you through translating a research-computing topic into a brief that survives a faculty curriculum committee.

Module 2. The reproducibility checklist

Build the checklist students sign before submission. Items include the exact compiler version, the scheduler script, the input data hash, the random seed, the wall-clock and CPU-time numbers, and the environment module list. Without the checklist, marking a parallel-computing assignment becomes archaeology. With it, the marker reproduces the result in under fifteen minutes.

Module 3. The rubric and weighting

Author the rubric students will be marked against. Categories cover correctness, scaling behaviour, code clarity, write-up structure, and reproducibility. Each category gets a 0-4 scale with anchored descriptors. The rubric is shared with students on day one so the assessment is a known target, not a surprise.

Module 4. The peer-review worksheet

Design the worksheet pairs of students fill in for each other one week before submission. Students mark each other against the rubric, surface obvious errors, and write a one-paragraph improvement note. The worksheet has to be specific enough that students cannot just write 'looks good'. The course gives you the question prompts that force concrete feedback.

Module 5. The cluster-access policy for the module

Write the policy that governs how students consume cluster resources during the module. Walltime caps per job, queue choice, total CPU-hours per student, fair-share weighting, and the abuse-handling path when one student's runaway job blocks the queue for everyone else. The policy is a one-pager students acknowledge in writing before they get the account.

Module 6. The scheduler script template

Hand students a known-good scheduler script (SLURM sbatch, PBS qsub, or LSF bsub) they can modify rather than write from scratch. The template includes resource requests, output redirection, module loads, and the timing harness that produces the speedup numbers the rubric will mark. The template is what most students lose three days to without.

Module 7. The data and code submission packaging

Define what students upload at submission time. The packaging is a single archive with a fixed directory layout: code, scheduler script, input data hashes, timing output, write-up PDF, and the signed reproducibility checklist. A fixed layout means the marker can navigate every submission identically and the script that runs the parallel correctness check works on every archive.

Module 8. The write-up structure

Specify the sections, length, and figure requirements for the write-up. Introduction with the problem statement and a single hypothesis. Methods including the scheduler script and the cluster configuration. Results with the speedup curve and a discussion of where the curve flattens. Conclusion in three sentences. Students who follow the structure produce markable work. Students who do not get the structure handed back.

Module 9. The marker calibration session

Run a one-hour session before marking begins where every co-marker grades the same three sample submissions against the rubric. Disagreements are surfaced, the rubric anchors are clarified, and the team agrees on edge-case handling. The calibration is what keeps grading consistent across markers and removes the appeals that come from inconsistent treatment.

Module 10. The viva script

Author the viva questions the student is asked at defence. The script is anchored to the rubric: one question per rubric category, plus a probe question about the result the student would most expect to be challenged on. The viva produces a final mark that the student understands and can reconcile against the rubric afterwards.

Module 11. The grade moderation and appeal handling

Define the path for a student who disagrees with their mark. The moderation policy uses the rubric and the viva transcript, not the marker's memory. Most appeals collapse when the student is shown the rubric category they were marked down on and the specific evidence from their submission. The course gives you the appeal-response template that closes appeals fast and fairly.

Module 12. The module retrospective and next term

Run the end-of-module retrospective. What worked, what produced the most supervision overhead, which rubric category had the widest mark spread, which scheduler errors recurred. The retrospective writes the patch list for the next term's revision. The course closes with the retrospective template and the change-log format you keep so the module improves rather than gets rewritten every year.

How this addresses your situation

Specific modules that map to what you said you are dealing with.

If your module currently exists as office-hours conversations and a slide deck, start with modules 1 and 3 to anchor the brief and the rubric.

If you have the rubric but supervision still consumes the term, jump to modules 4 and 7 to install peer-review and submission packaging.

If marking varies across co-markers, modules 8 and 9 install the structure and calibration that close the variance.

If your cluster runs hot during assignment weeks, module 5 produces the access policy that protects the rest of the queue.

What you get with this course

All 12 written modules in the Art of Service learning environment.
Module brief template, rubric template, reproducibility checklist, peer-review worksheet, cluster-access policy template, scheduler script template, viva script, retrospective template.
Worked examples for a SLURM, a PBS, and an LSF environment so the templates run on whichever scheduler your cluster uses.
The hand-built implementation playbook tailored to your department's cluster size, scheduler, and course catalogue, delivered alongside course access.

What you will have in hand by Day 1, Week 1, Month 1

Within 24 hours, your account in the learning environment is provisioned and the tailored implementation playbook is delivered alongside it.

Week 1: module brief, rubric, reproducibility checklist drafted.

Week 2: peer-review worksheet, cluster-access policy, scheduler script template in place.

Week 3: submission packaging, write-up structure, marker calibration session run.

Week 4: viva script and moderation policy authored.

Week 5: retrospective template installed, ready for the cohort.

Before and after

Before

After

Students submit against a known rubric they have already peer-reviewed each other against, markers calibrate in one hour, vivas run from a script, appeals are resolved against rubric evidence, and the next term's module starts from a written change-log of what to revise.

What happens if you do not address this

Who it is for

A research computing academic or HPC teaching lead at a university, responsible for both the cluster's day-to-day shape and the curriculum that puts students on it. You teach, supervise, and administer at the same time. You have a scheduler (SLURM, PBS, or LSF), a small fleet of compute nodes, and a course that needs more structure than your office hours can carry.

Who this is NOT for. Industry HPC engineers building production pipelines. Pure research staff with no teaching load. Faculty leads buying institutional licenses without authoring the teaching module themselves.

How it arrives

Text-based course in the Art of Service learning environment, plus downloadable templates and worked examples for every module, plus the hand-built implementation playbook delivered alongside course access.

Time investment. Four to six hours per week for five weeks, with most of the work producing artefacts your department will use term after term.

Why $199 is the right number

Generic HPC training from a vendor teaches students to run jobs, not academics to author an assessable teaching module. Pedagogy courses from a teaching centre teach assessment design in the abstract without naming a scheduler, a queue, or a reproducibility checklist. This playbook sits in the gap: research-computing specific, teaching-module specific, ready to drop into a course catalogue.

FAQ

Does this assume a particular scheduler?

No. Worked examples cover SLURM, PBS, and LSF. The rubric, peer-review worksheet, and viva script are scheduler-agnostic.

What if my department does not have a dedicated cluster, only shared institutional access?

The cluster-access policy module covers shared-resource cases. The policy template includes fair-share weighting and a runaway-job handling path for shared environments.

Can I use this for postgraduate supervision rather than undergraduate teaching?

Yes. The rubric and viva script transfer directly to postgraduate research-computing modules. The peer-review worksheet is most useful when cohort size justifies it.

How is fulfilment handled?

Within 24 hours your account in the learning environment is provisioned and the tailored implementation playbook is delivered alongside it. The playbook is hand-built for your department's cluster size, scheduler, and course catalogue.

30-day money-back guarantee. If after a week of working through the materials this is not what you needed, reply to the receipt email and a full refund is processed. No questions, no forms.

Within 24 hours your account in the learning environment is provisioned and the tailored implementation playbook is delivered alongside it.