TITLE: Back To My Compilers Course
AUTHOR: Eugene Wallingford
DATE: August 27, 2021  3:30 PM
DESC: 
-----
BODY:
 Well, a month
<a href="http://www.cs.uni.edu/~wallingf/blog/">
   has passed</a>.
 Already, the first week of classes are in the books.  My compiler
 course is off to as good a start as one might hope.

 Week 1 of the course is an orientation to the course content and
 project.  Content-wise, Day 1 offers a bird's-eye view of
 <em>what</em> a compiler does, then Day 2 tries to give a
 bird's-eye view of <em>how</em> a compiler works.  Beginning next
 week, we go deep on the stages of a compiler, looking at techniques
 students can use to implement their compiler for a small language.
 That compiler project is the centerpiece and focus of the course.

 Every year, I think about ways to shake up this course.  (Well,
 not last year, because we weren't able to offer it due to COVID.)
 As I prepared for the course, I revisited
<a href="https://eschew.wordpress.com/2020/01/26/undergrad-compilers-from-the-hive-mind/">
   this summary</a>
 of responses to
<a href="https://twitter.com/johnregehr/status/1220774524532056065">
   a Twitter request</a>
 from John Regehr:  What should be taught in a modern undergrad
 compiler class?  It was a lot of fun to look back through the many
 recommendations and papers linked there.  In the end, though, the
 response that stuck with me came from
<a href="https://twitter.com/cahollenbeck">
   Celeste Hollenbeck</a>,
 who "noted the appeal of focusing on the basics over esoterica":
 compilers for the masses, not compilers for compiler people.

 Our class is compilers for everyone in our major, or potentially
 so.  Its main role in our curriculum is to be one of four so-called
 project courses, which serve as capstones for a broad set of
 electives.  Many of the students in the course take it to satisfy
 their project requirement, others take it to satisfy a distribution
 requirement, and a few take it just because it sounds like fun.

 The course is basic, and a little old-fashioned, but that works
 for us.  The vast majority of our students will never write a
 compiler again.  They are in the course to learn something about
 how compilers work conceptually and to learn what it is like to
 build a large piece of software with a team.  We talk about modern
 compiler technology such as LLVM, but working with such complicated
 systems would detract from the more general goals of the course for
 our students.  Some specific skills for writing lexers and scanners,
 a little insight into how compilers work, and experience writing a
 big program with others (and living with design decisions for a
 couple of months!) are solid outcomes for an undergrad capstone
 project.

 That's not to say that some students don't go on to do more with
 compilers...  Some do.  A few years ago, one of our undergrads
 interviewed his way into an internship with Sony PlayStation's
 compiler team, where he now works full time.  Other students have
 written compilers for their own languages, including one that was
 integrated as a scripting language into a gaming engine he had
 built.  In that sense, the course seems to serve the more focused
 students well, too.

<em>Once more unto the breach, dear friends, once more...  <br/>
-- Henry V</em>

 So, we are off.  I still haven't described the source language my
 students will be processing this semester, as promised in my last
 post.  Soon.  Since then, though, I wrote a bunch of small programs
 in the language just to get a feel for it.  That's as much fun as
 a department head gets to have most days these days.  
-----