It would have been if the papers covered were closer to the state of the art.
The most recent one is from 2015.
However, this course would actually give you the background required to read more recent paper and work on compiler research, so calling it PhD level is not a huge stretch.
Even if you're working at the PhD level, a course is only going to at best give you a survey of material instead of the latest-and-greatest papers hot off the presses at PLDI or ASPLOS or whatever conferences matter most for your field. If you're actually doing research on a particular subfield, then you are going to be finding and reading those papers on your own.
In that vein, it makes a lot more sense to focus on a solid, foundational paper than whatever incrementalism came out most recently. SLP vectorization is a good example here--yeah, the foundational paper is 20 years old at this point, but you'd rather students read and understand that than whatever the most recent addition to SLP vectorization came out in this (or last) year's PLDI. Even the other papers I think I might add or substitute for others in this course aren't going to be substantially newer than the stuff already here.
I mean a lot of programming language design goes back decades; it's better to focus a course on the basics that every language will have vs the most recent developments that haven't fully crystallized yet either.
There is a critical difference between programming language design and compiler design.
You are right when it comes to programming language design and somewhat wrong when it comes to compiler design.
If you are doing compiler research/development, you have to be familiar with the latest and greatest research because the margins for improving things are fairly slim. It’s usually fine to be not familiar with how things worked ~30 years ago.
For programming languages, you absolutely have to understand the foundations to do absolutely anything.
> If you are doing compiler research/development, you have to be familiar with the latest and greatest research because the margins for improving things are fairly slim. It’s usually fine to be not familiar with how things worked ~30 years ago.
On the other hand, if the margins for improving compiler quality are slim they can be ignored without great consequences: it makes sense to study state of the art research only in the niches that turn out to be relevant for a specific need of a specific project, not blindly and at the expense of important general principles and techniques (i.e. mostly the problems of 75 years ago and the solutions of 25 years ago).
Again this is not necessarily for someone doing compiler research, but foundational knowledge for anyone at the PhD level.
Someone doing compiler research this might be a first graduate level course to get them used to the technique and concepts used in more recent research for the might have two or three additional courses getting closer and closer to state of the art.
I took this course when it was PL-focused in 2015ish! It starts with an in-depth exploration of the untyped lambda calculus (with the usual fixins like Church numerals, various combinators, etc), spending half a week or so on semantic expansion rules, reduction strategies, recursion, fixpoints, continuations, how one might encode state with only lexical closures, etc. After maybe the tenth lecture, the class takes a quick detour to talk about predicate logic, Hoare logic, dynamic logic, and Kleene algebra, before deriving a typed variant of the lambda calculus as an illustrative pathway into the latter half of the course featuring algebraic datatypes, unification, type inference, and the duality between formal logic propositions and typing systems. We explored subtype polymorphism, bisimulation, equirecursive equality, and closed on a gentle introduction to monads (of all things) and a teaser of category theory (which IMO should have been taught first but oh well).
As more of a math course than a computer engineering course, 6120 was a first-semester Ph.D. level class, and I certainly wouldn't recommend taking it unless you really wanted to dive deep into the depths of programming language implementation. Incoming students were expected to be fluent in discrete mathematics and formal proofwriting skills. I wasn't, so I found myself falling behind at the start even though I had some familiarity with lambda calculus and algebraic datatypes. You definitely benefit from a strong math background.
I've seen it like 2 years ago and it is well prepared course.
>CS 6120 is a PhD-level Cornell CS course by Adrian Sampson on programming language implementation.
I just dont understand why is this "PhD level"