On 17 November 2026, CMU’s CS Learn page listed only one ML-relevant course as “Watch now”: William Cohen’s 10-605 Machine Learning with Large Datasets. That is immediately useful if your gap is Spark and large-data processing. It is not a ready-made course in vLLM kernels, GPU memory management or distributed serving.
For those systems gaps, queue 15-442 Machine Learning Systems, taught by Tianqi Chen and Zhihao Jia, but check that its premiere videos have actually appeared before scheduling a study session. Add 17-645 Machine Learning in Production for deployment practice when it premieres on 19 November. Also plan your own exercises and review process: CS Learn currently offers free classroom lectures, while interactive courseware, assessment and AI tutoring remain announcements rather than shipped features.
What CMU has actually released
The launch is real and is separately announced on CMU’s School of Computer Science homepage. The important distinction is between a course being listed, a premiere being scheduled and videos being watchable.
| Course | Status on CS Learn when checked on 17 November | Best-supported use | Practical decision |
|---|---|---|---|
| 10-605 Machine Learning with Large Datasets, William Cohen | “Watch now” | Large-data systems. A community syllabus summary points to MapReduce, Spark and data cleaning. | Start now if that matches your work. Do not choose it as a GPU-kernel or serving course. |
| 15-442 Machine Learning Systems, Tianqi Chen and Zhihao Jia | “Premieres Tue, Nov 17” | The strongest title-level match for ML-systems fundamentals, but no syllabus or sample lecture was available in the evidence. | Queue it for memory, scheduling and systems questions; verify that the videos are live and inspect the syllabus when available. |
| 17-645 Machine Learning in Production | Scheduled for Thu, Nov 19 | A plausible deployment-practice complement, inferred from the title rather than confirmed course content. | Add it to the queue for production concerns, not as an immediately available fix. |
The only other course marked “Watch now” was 15-110 Principles of Computing, which is introductory computing rather than the systems training at issue here. The rest of the November rollout includes 17-635 Software Architectures and 17-643 Quality Management on 18 November, plus 11-768 AI Agents alongside 17-645 on 19 November. A second wave, including Probability and Computing, Multimodal Machine Learning and AI and Machine Learning I, is scheduled for January 2027.
Those dates are useful for planning a queue, not for promising a team that material will be available on a particular morning. In particular, the 15-442 listing still said “Premieres” when the page was fetched on its premiere date. This audit cannot establish that its videos were live at publication time.
The course you can watch now solves a different problem
The only visible syllabus evidence for 10-605 is a community summary of the Spring 2020 course, cross-listed as 10-405/10-605. Its opening lectures cover distributed computing and MapReduce, an introduction to Spark, data cleaning, and Spark joins, structures and DataFrames.
That is a coherent reason to watch it. An engineer responsible for large training-data pipelines, distributed data processing or Spark jobs could use it to formalize concepts encountered at work. It is much less defensible as preparation for diagnosing a vLLM serving bottleneck or deciding whether a Triton kernel is behaving correctly.
The syllabus evidence also has a limitation: it is a third-party summary of a 2020 offering, and the CS Learn recording may differ. It is enough to establish that the visible course outline is oriented toward large-data systems. It is not enough to specify every lecture in the newly released version.
I would therefore choose 10-605 because large-data systems are your current gap, not merely because it is the first available ML course. Availability is a poor substitute for curriculum fit.
Which systems gap are you trying to close?
The independent research evidence helps define what useful ML-systems instruction should enable you to reason about. It does not establish that 15-442 covers these topics. With no syllabus or sample lecture in the evidence, that connection remains an inference from the course title and instructors.
Memory reuse and dependency scheduling
A formal systems course should explain why two implementations of the same computation can have very different memory requirements and execution timelines.
The MXNet systems paper supplies a concrete model. Its authors describe in-place and co-share memory-reuse strategies, reporting memory savings of roughly 2× during training and 4× during prediction. Its dependency engine tracks data dependencies across computation graphs and imperative operations, then schedules operations across CPUs, GPUs and memory or PCIe buses.
Those mechanisms give you specific questions to bring to 15-442:
- When is it legal to reuse a tensor’s storage?
- Which operations must wait because they share data, even if no explicit synchronization appears in the source?
- How can computation, memory transfers and device work be scheduled without violating those dependencies?
- What information would you need to explain excess allocation or an unexpected stall in your own stack?
If the lectures help you answer those questions, they are addressing a durable systems gap. If they remain at the model or algorithm level, they will not substitute for that work, whatever the course title suggests.
Triton kernels require more than API familiarity
Triton matters directly to the reader’s stack: the ML-Triton paper identifies it as a kernel-development language used by vLLM, Mamba and DeepSpeed. The paper also describes multi-level compiler lowering that reflects the GPU hierarchy. Understanding that relationship between source code, compilation and hardware execution is more useful than memorizing kernel syntax alone.
The limits are workload-specific and sometimes severe. In an author-reported comparison of an irregular, hash-blocked GPU workload, Triton was more than an order of magnitude slower than hand-written CUDA C++ on the irregular probing-and-insertion stage. The authors attribute the gap to compile-time-bounded probe loops and to tl.atomic_cas lacking a mask, which forced scratch structures; they also report silent data loss at high hash load factors.
That is not evidence that Triton is generally slower than CUDA. It is evidence that irregular control flow and atomic operations can change the implementation choice, and that a fast-looking kernel still needs correctness checks.
A second author-reported example gives useful checkpoints without generalizing them to every Triton project. The rl-triton kernel work required float32 inputs, deferred bfloat16 support pending precision analysis, encountered Triton’s internal block-size limits and reported kernel-launch-count differences from torch.compile.
For self-study, these papers suggest a practical standard: after the relevant lectures, you should be better equipped to ask how a kernel handles data types, block dimensions, loops and atomics, and how you would validate its output. The papers supply the test cases; CS Learn has not yet supplied the feedback loop.
Cluster placement and reliability are systems problems too
GPU work does not stop at kernel correctness. Placement decisions can affect job performance, and operations teams need to distinguish an application regression from hardware variability.
The authors of the PAL scheduling study report outlier GPUs more than 2.5× slower than the cluster median. They propose PM-First placement, which treats PM-induced variability as a primary job-placement factor, and use K-Means clustering of GPU variability to make the scheduling approach workable for large clusters. These are author-reported findings from that study, not a universal slowdown factor for GPU fleets.
Reliability adds another operational dimension. Falcon, a GPU-failure prediction system, was evaluated across four held-out faults and then produced a high-confidence alert stream during a one-month deployment on a cluster of more than 10,000 GPUs, according to its authors.
These examples separate two learning goals that are easy to collapse into “distributed serving”:
- Systems reasoning: memory, dependencies, scheduling and hardware variability, for which 15-442 is the title-level candidate.
- Production practice: deploying, operating and responding to problems in ML services, for which 17-645 is the plausible complement.
Neither course’s coverage of cluster placement, failure prediction or serving has been verified here. Treat those as topics to look for when syllabi become available, not promised modules.
Free lectures still leave you running the course
CS Learn describes a clear sequence on its launch page: full classroom lectures on YouTube first; self-paced courseware with lessons, instant feedback and badges next; AI tutoring within that courseware afterward. No launch dates are attached to the latter two stages.
That changes the workload for an individual learner and for a team lead. A video can supply explanation, but the announced mechanisms for checking understanding and helping a learner get unstuck are not yet available. Do not equate access to lectures with a complete self-paced course.
A workable study plan for the video-only period is:
- Choose one concrete gap before pressing play. For example, unexplained memory growth, an irregular kernel that needs validation or unexpected variation between GPUs. Keep the example bounded to your own workload.
- Write down the mechanism you expect the lecture to explain. Use questions such as when memory can be reused, which dependencies constrain execution or how compiler choices affect kernel structure.
- Pair the lecture with a primary paper and a small exercise. The papers above provide concrete cases to compare against your mental model. They do not prove that your system will show the same behavior.
- Arrange external review. A colleague, reading group or code-review process can challenge your explanation and test results. This is a substitute you supply yourself, not functionality CS Learn currently promises.
- Reassess when courseware arrives. Instant feedback and badges could reduce some of this overhead, but their content, timing and effectiveness are not yet established.
For a team, I would approve 10-605 study time now for engineers working on large-data and Spark problems. For vLLM, Triton and GPU-serving gaps, I would build the plan around 15-442’s expected systems material and 17-645’s expected production perspective, while making participation conditional on a quick syllabus check once those materials appear.
Before recommending either premiere course broadly, recheck the CS Learn page or YouTube channel for live videos and look for a syllabus or sample lecture. All availability and roadmap claims here originate with CMU’s own launch statement, and there is no independent assessment of teaching quality or lecture depth in the evidence. The defensible decision today is therefore narrow: use the available large-data lectures where they fit, queue the systems and production courses with verification steps, and budget for your own practice and assessment rather than waiting for announced tutoring to do that work.
Frequently Asked Questions
Which CMU ML course is available to watch immediately on CS Learn?
On 17 November 2026, CMU’s CS Learn page listed only one ML-relevant course as “Watch now”: William Cohen’s 10-605 Machine Learning with Large Datasets.
What is the current status of the 15-442 Machine Learning Systems course?
For those systems gaps, queue 15-442 Machine Learning Systems, taught by Tianqi Chen and Zhihao Jia, but check that its premiere videos have actually appeared before scheduling a study session.
What features of CS Learn are not yet available?
CS Learn currently offers free classroom lectures, while interactive courseware, assessment and AI tutoring remain announcements rather than shipped features.

Join the discussion
Share a useful perspective or ask a question about this article.