Stanford Compilers Course

https://lagunita.stanford.edu/courses/Engineering/Compilers/Fall2014/about

by tu7001 • 9 years ago

387 79 9 years ago

lagunita.stanford.edu

dhawalhs• 9 years ago

More Stanford free online courses/MOOCs(over 150) here: https://www.class-central.com/university/stanford

2_listerine_pls2• 9 years ago

Too bad Stanford doesn't care much about free material as MIT does.

sn94• 9 years ago

Check out Stanford's Lagunita.

amelius• 9 years ago

They still reference the Dragon book, but how relevant is it still? I recall that a lot of it deals with parsing (which nowadays seems an almost trivial problem), and it doesn't treat garbage collected runtime systems, or JIT compilers. Or type inference with any of the newer typesystems as used by e.g. Rust, or even Hindley Milner.

virgilp4• 9 years ago

This is an undergrad-level course. Of course it needs to teach parsing - a lot of people are going to have to write some form of parser during their career, so it's good to have some fundamentals. (and the Dragon book doesn't exclusively talk about parsing, either)

megaman22• 9 years ago

Man, it's really unconscionable the way that textbooks juice people. There is no reason that book ought to cost $190 (what I just saw on Amazon for the hard-cover). It's across the board; once a book gets entrenched as one of these go-to textbooks for a subject, it can for some reason be marked up 400% over equivalent books.

monocasa• 9 years ago

The second edition covers techniques for VMs like garbage collection.

CalChris2• 9 years ago

The 2nd Edition of the Dragon Book covers dynamic compilation (JIT) and garbage collection. GC gets about 40 pages. It’s still my favorite.

top256• 9 years ago

They have a new edition covering new subjects. Also they're explaining the big principles behind compilers. That's why the book is still relevant (I'm working at a compiler startup)

ychen3062• 9 years ago

They are relevant. These are orthogonal issues. Typically there are more than one compiler courses in university, and you can go into more details if need to.

virgilp4• 9 years ago

I hate it that you can't see the syllabus without signing in. How is someone supposed to know whether (s)he's interested?

I've looked over it, it's not too dissimilar (on surface) with what I used to teach at the university. Might not be an accident since I remember at some point we switched from our own compiler skeleton to COOL, which is apparently what Stanford uses; so maybe I inspired my syllabus from Stanford's? I forget :) (for sure I did check the syllabi of several big US universities when building mine).

Interesting that he recommends "Engineering a Compiler"; I don't doubt that it's a good book but I don't know it. The third on my list (though admittedly a bit advanced) was Muchnick's "Advanced Compiler Design and Implementation".

rayiner4• 9 years ago

Muchnik covers a lot of ground, so is pretty dense. Cooper & Torczon's book is more approachable, though it covers less ground. In some cases, Cooper & Torczon choose which algorithms to present because they're easier to understand. (E.g., they don't cover partitioning-based value numbering, but rather a simpler hash-based technique.)

CalChris2• 9 years ago

Muchnick deserves a second edition. He’s retired but someone should take on the task.

hawflakes• 9 years ago

As I recall, the same professor also taught a compiler class using COOL back in 1995-96 at Cal. I sat in on a session because a friend was taking it at the time.

gfredtech2• 9 years ago

A few days ago I had to download this course (along with Stanford's course on Automata theory) from a torrent tracker because it was no longer available on Coursera...

leadingthenet• 9 years ago

Any idea why they're no longer on Coursera?

gfredtech2• 9 years ago

Sadly, no

k4ch0w• 9 years ago

This happened to a linear algebra course I wanted to take. It was on Coursera and for some reason removed.

rz2k• 9 years ago

Link to the Automata course:

https://lagunita.stanford.edu/courses/course-v1:ComputerScie...

sn94• 9 years ago

They're both on Stanford's Lagunita, along with excellent courses on Computer Networks and Databases.

jcadam• 9 years ago

My compilers course was the single most difficult college course I've ever taken (it was an undergrad/graduate cross-listed course usually taken senior year, and at least at my school, UCCS in Colorado, was the cause of many a CS student not graduating on time -- putting a weed-out course that close to the end of the BSCS program wasn't cool, man).

More all-nighters during that class than any other. It occurs to me, I've spoken to several Junior devs over the last few years with CS degrees that never had to take a compilers course. That just isn't right.

Herald_MJ• 9 years ago

It was an optional course for me, and also one of the hardest I took. But also one of the most enlightening, rewarding, and enjoyable of my degree.

kochthesecond• 9 years ago

It was optional in my degree, and I concur it was the single most difficult course I took. At least twice as much work as any other course, learned twice as much too.

tombert• 9 years ago

As an autodidact, I really appreciate that the big "brand-name" universities do this. MIT OpenCourseware and the free Stanford lectures have been so incredibly valuable in making me an at-least-half-decent engineer.

I've written a Scheme interpreter a few years back, but never a compiler, so this should be a pretty fun time-dump for the weekends.

yodsanklai2• 9 years ago

I especially like when courses are not watered down. For instance, many coursera courses are simplified to be accessible to a broader audience with limited background. When I want to dig deeper, I really enjoy some of MIT opencourseware classes.

jamestimmins2• 9 years ago

Can you recommend any MIT ocw courses that are challenging while being high quality? Some of them don't have video lectures or are quite hard to follow without TA/teacher help, that I've been hesitant to try them out again.

pjmlp• 9 years ago

Have a look at "An Incremental Approach to Compiler Construction", you might find it interesting.

http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf

seanmcdirmid• 9 years ago

Not to be confused with “an approach to incremental compiler construction.”

ellius• 9 years ago

I have no illusions that this is likely to happen, but if I ever hit it big, the first thing I will do is donate a good chunk of change to educational programs like MIT OpenCourseware. It is extremely generous to make this stuff freely available, and has contributed immensely to my ability to educate myself.

nfriend• 9 years ago

I took this course for fun a few years ago - it was fantastic! I modified the project a bit to match my own interests - instead of compiling to an executable, my compiler generated browser-friendly JavaScript code. I built a small web application that uses my compiler and allows you to run COOL code in your browser: http://nathanfriend.io/cooltojs/

dbrgn• 9 years ago

I also did the course, in parallel to the "real" university course. Both had almost the same structure since they're both roughly based on the dragon book.

I can strongly recommend it - really great material!

bitL• 9 years ago

For those of you who took it - does it go into detail how to do advanced LALR languages, including handling semantics and types? Can I use the knowledge to make my own OOP + FP language right away (Scala/Kotlin-like), or do I need to study much much more than what is covered in this course? Thanks!

jfoutz• 9 years ago

I didn't take this course. I have taken compiler classes.

Short answer, yes.

Longer answer, compilers of any sort are hard, because there's both a lot of special cases and also pressure to be algorithmically efficient.

Writing any kind of compiler is going to force you to do stuff with the parse tree. It's up to you to decide if

   float a = 1

is an error or not. doing things like constant value evaluation

   int a = 1 + 2 + 3
   =>
   int a = 6

will get you a feel for all the different ways you can transform the parse tree. It's going to feel frustrating, because it's not the language you want to work on. But building up the skills to shuffle ast nodes is really really helpful.

Making your own language is hard. if your goal is a working language, i'd suggest building an interpreter first, so you can really nail down the semantics. at the end of that you're going to have a call that looks like eval(ast, context). you can do a simple compiler by just reimplementing eval, rather than doing the work, spit out the code that would do the work.

also, if you have an adequate interpreter, you can you can write your compiler in your own language.

tom_mellior• 9 years ago

Can I use the knowledge to make my own OOP + FP language right away

I didn't take this course, but from the syllabus posted above it looks like garbage collection is not covered at all. That's pretty much a requirement for FP languages, and it makes OOP languages easier too. So you'd have to look at other resources for that. A simple semispace collector should be relatively easy to write even if you don't want to get too deep into the matter.

For a very first version of your language, you can of course just allocate memory without ever freeing it. That's good enough to experiment with simple programs.

Another point that I think isn't covered in this course, and that is relevant for (many) functional languages, is pattern matching and the representation of algebraic datatypes.

tomku• 9 years ago

I took the course several years ago and finished it. It's focused on the basic concepts of compiler implementation with the example language (COOL) being pretty traditionally object-oriented. It's absolutely not a how-to course on how to implement advanced language features.

stevefan1999• 9 years ago

Yes! This is what I’m exactly looking for! By the way, what other free compiler courses would you hackers recommend?

tdaniels• 9 years ago

I have worked through the following, and found it quite good http://www.diku.dk/~torbenm/Basics/basics_lulu2.pdf

*Full disclosure that the following is mine https://troydaniels.github.io/diku/compiler/course/2017/01/0...

zellyn• 9 years ago

I did the Coursera version of this course a few years ago. I didn't read any book, but definitely watched parts of the videos more than once.

Their scaffolding code is only available for C++ and Java, but (at least when I took it) many of the tests could be downloaded and reverse-engineered, so I was still able to adequately test my Go implementation. See https://github.com/zellyn/gocool for my working but probably quite nasty code :-)

dochtman• 9 years ago

I also took the Coursera version, and I have a Python version of the tooling for those who are interested:

https://github.com/djc/cs143-python

chmaynard• 9 years ago

I believe this course was developed by Alex Aiken during his time at Berkeley. I assume he brought the material with him when he moved over to Stanford. The Cool language as a didactic tool seems a little dated now. When I took the Coursera version of the course a few years ago, Aiken distributed the Cool compiler development environment as a VirtualBox image, which was a nice cross-platform solution at the time. Today, Docker would probably be the preferred approach. I didn't get very far in the course because I lacked the necessary C++ skills (and the motivation to learn them).

hiram112• 9 years ago

Could someone who has taken a decent compiler course and been in the industry a few years comment on how / why this course would be beneficial?

There are a lot of things I'd like to look into these days, but only so much time. And I do realize that some courses I took in University a decade ago were far more valuable than others (e.g. learning to program the m68K was extremely useful just to understand how stacks, interrupts, etc. work. OTOH, I haven't used anything from in my programming languages course since then).

adam_gyroscope• 9 years ago

I took this course a few years back when it was on Coursera and had taken a similar course many years ago in university; I've been a developer of some kind for 20+ years. This course brought together a bunch of stuff I understood but hadn't internalized so didn't use in my day-to-day job.

If you've been programming for a few years and take this course, you're going to say "OHHH that explains <some weird thing that happened in your career>" a bunch.

zmodem• 9 years ago

I can't comment on this course specifically, but the argument for studying compilers, even if you don't end up working in that field, is that learning how programs are translated gives a deepter understanding of how computers are programmed. From a practical view-point, it's useful to know what a compiler can and cannot do with your program.

Niklaus Wirth puts it like this:

"It is the essence of any academic education that not only knowledge, and, in the case of an engineering education, know-how is transmitted, but also understanding and insight. In particular, knowledge about system surfaces alone is insufficient in computer science; what is needed is an understanding of contents. Every academically educated computer scientist must know how a computer functions, and must understand the ways and methods in which programs are represented and interpreted. Compilers convert program texts into internal code. Hence they constitute the bridge between software and hardware.

Now, one may interject that knowledge about the method of translation is unnecessary for an understanding of the relationship between source program and object code, and even much less relevant is knowing how to actually construct a compiler. However, from my experience as a teacher, genuine understanding of a subject is best acquired from an in-depth involvement with both concepts and details. In this case, this involvement is nothing less than the construction of an actual compiler."

(From http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf)

mikeurbach• 9 years ago

I can't comment on this specific course, but I took a compilers course from Tom Cormen that completely changed how I thought about computing. After several years in industry, it's not so much the specific techniques of constructing a compilers that remain useful, but the mode of thinking I learned.

I had an AHA moment along the lines of "Wow, the compiler writer is basically God." I had taken courses in software development and hardware architecture, but after writing a compiler I saw first-hand how a program--a description of a solution to a problem in a human readable language--is converted to the same description in a hardware readable language. The meaning of the program must be preserved by the compiler, but otherwise it has the freedom to generate any one of potentially many outputs that preserve the meaning.

There is a beauty I realized in the relationship between the programmer, the programming language, the compiler, and the hardware architecture. They are all in cahoots, but the compiler is the cornerstone. That relationship doesn't directly affect my decisions as a professional software engineer, but it forms the backdrop upon which I think about the act of programming and computing in general.

saltcured2• 9 years ago

It's been two decades since I took the origins of this course at UC Berkeley. Understanding the material from this course (and the Dragon Book in general) should change the way you think about many forms of data processing. I think this topic is absolutely foundational to a well-rounded CS education. It's important to understand a little about tool-building rather than just tool-use if you want to master your craft.

I haven't reviewed his new syllabus in depth, but even 20 years ago, Alex had reduced the focus on parsing compared to more traditional syllabi based on the Dragon Book. You were expected to do some homework and self-study to learn the basic parsing and lexing concepts. The reason for COOL was to get you into the other compiler-construction topics sooner to get some breadth of exposure to concepts like abstract syntax trees, semantic checking, type systems, intermediate languages, code-generation, and the rough idea of runtime systems and ABIs.

Taken together with an operating systems course, these are really two different examples of systems engineering concepts. You should be able to take away not just some vertical silo of knowledge only applicable to "building a compiler" or "writing an OS". You should be able to fuse these concepts into a richer understanding of how to decompose and engineer complex systems given a range of specialized and more general-purpose requirements.

Another facet of this can be found in courses focused more on database construction and storage, but this starts to veer out of the introductory space. Unfortunately, most introductory database courses focus too much on using a database and writing applications instead of on understanding how they work and what the engineering tradeoffs actually are.

rifung4• 9 years ago

Recently, a coworker of mine told me how she thought the compiler should catch when you don't give printf the right arguments. Another example is when a coworker said you couldn't define flags in a Go library but she didn't realized you would have to import the package from that library to force the code to run first.

In my mind, both of these examples showed a lack of understanding in how the compiler works. I would say learning about compilers should help with being able to make good assumptions of how things work. Whether it's worth the rare times it comes in handy is probably dependent on what else you could learn.

Note that I actually didn't take a compilers course myself and said co-workers did, so I can't say for sure even taking a course is sufficient (but I am currently reading a compilers book, though out of enjoyment and not for career skills). I should also say I believe my co-workers are significantly better developers/employees than I am.

glangdale• 9 years ago

Recently, a coworker of mine told me how she thought the compiler should catch when you don't give printf the right arguments.

The fact that you think she's wrong, and that you're right, on this issue, suggests you don't understand how compilers work either. 99% of printf fails are catchable through static analysis, and should be caught that way.

alexashka2• 9 years ago

It's beneficial if it's an itch that you want to scratch.

For me, compilers, operating systems, databases, networks, processors are foundations upon which everything else is built. I'd like to know a little bit about the foundation upon which I'm making a living.

Some folks just want to get things done. I think it's just a personality thing.

keithnz• 9 years ago

I haven't been on a decent compiler course, for the most, I taught myself. I find that I constantly invent mini languages. For instance, I do a lot with timeseries data, and do a lot with bringing in all kinds of external sources of data in many weird formats, so I have a simple data transfomation language that deals with 90% of the scenarios I encouter. Also have a various device simulation languages for describing various sensors and their interfaces, eg SDI12 with it's various timing constraints and sequences. As part of a broader embedded board based testing system the mini language is used to say how you want a sensor to be simulated and then you can execute tests to ensure things work

sn94• 9 years ago

If you want an entertaining if opinionated defense for studying compilers, Steve Yegge's got ya covered: https://steve-yegge.blogspot.com/2007/06/rich-programmer-foo...

dolguldur• 9 years ago

Syllabus:

Week Videos Quiz / Exam PA assigned PA due

1 Course Overview | Cool: The Course Project

2 Lexical Analysis | Finite Automata Quiz #1 PA1

3 Parsing | Top-Down Parsing Quiz #2

4 Bottom-Up Parsing I | Bottom-Up Parsing II Quiz #3 PA2 PA1

5 Semantic Analysis and Type Checking | Midterm

6 Cool Type Checking | Runtime Organization Quiz #4 PA3 PA2

7 Code Generation | Operational Semantics Quiz #5

8 Local Optimization | Global Optimization Quiz #6

9 Register Allocation | Garbage Collection PA4 PA3

10 Java | Final Exam

towndrunk• 9 years ago

This is worth a look if you have not seen it. https://interpreterbook.com/

DSingularity• 9 years ago

I have wonderful memories coding the lexer, parser, runtime, and code generation support for OO aspects of COOL. Knowing how inheritance and polymorphism were implemented really does bring some clarity to programming.

Compilers was one of my favorite courses. Definitely humbling and enlightening. Would recommend :D

avarsh• 9 years ago

I took a PL/Compilers course based on COOL with Wes Weimer at UVA. We built an interpreter and compiler for COOL using its manual (i.e. a document with a verbal/maths spec for the language) and virtually no skeleton code. It was the hardest class in the department and I consider it to be the most valuable class I took as an undergrad. Before that class I didn't really understand what happened when I 'hit go' on my programs. Weimer is at UMich now but still publishes course materials online: https://web.eecs.umich.edu/~weimerw/

Stanford Compilers Course

Related Stories