Simone Campanoni

Associate professor
Department of Computer Science at Northwestern University

Simone Campanoni

Computer Science
Northwestern University


CS 322: Compiler Construction


The compiler is the programmer's primary tool. Understanding the compiler is therefore critical for programmers, even if they never build one. Furthermore, many design techniques that emerged in the context of compilers are useful for a range of other application areas. This course introduces students to the essential elements of building a compiler: parsing, context-sensitive property checking, code linearization, register allocation, etc. To take this course, students are expected to already understand how programming languages behave, to a fairly detailed degree. The material in the course builds on that knowledge via a series of semantics preserving transformations that start with a fairly high-level programming language and culminate in machine code.

Department page


This class takes materials from two different books (listed in the syllabus) as well as a few research papers. The result is a set of slides, notes, and code. Some lectures rely on code and notes (not slides).
All the slides used in the 2023-2024 class are below. The rest of the material is available only on Canvas.
Materials are improved every year. They are updated on this website (atomically) only at the end of the class.

Week number First lecture Second lecture
Week 0 Welcome ( PDF ) ,
Framework ( PDF )
L1 ( PDF )
Week 1 From L1 to x86_64 ( PDF ) ,
Parsing ( PDF )
L2 ( PDF ) ,
Liveness analysis ( PDF )
Week 2 Panels about Homework #0: L1 compiler Interference graph ( PDF ) ,
Spilling ( PDF ) ,
Graph coloring ( PDF )
Week 3 Panels about Homework #1: Liveness,
Advanced graph coloring ( PDF )
An alternative register allocator: puzzle solving ( PDF )
Week 4 Panels about Homework #2: L2 compiler L3 and instruction selection ( PDF )
Week 5 Panels about Homework #3: L3 compiler without merging IR ( PDF ) ,
Back-end missing pieces ( PDF )
Week 6 Panels about Homework #4: L3 compiler LA ( PDF )
Week 7 Panels about Homework #5: IR compiler,
The Time-Squeezer research compiler ( PDF )
LB ( PDF ) ,
Competition rules ( PDF )
Week 8 Panels about Homework #6: LA compiler LC ( PDF ) ,
LD ( PDF )
Week 9 Panels about Homework #7: LB compiler Competition!

Hall of Fame

Students design and build a complete compiler able to translate an almost-C language to Intel x86-64 machine code. At the end of the class, the resulting compilers compete and the names of the students that designed and built the best compilers are reported below.

Year Name Picture
2023 - 2024 Ryan Wong and Ethan Havemann Hall of fame 2023
2022 - 2023 Julio Wang Hall of fame 2022
2021 - 2022 Riley (a11ce) Boksenbaum Hall of fame 2021
2020 - 2021 Peter Zhong and Max Paik Hall of fame 2020
2019 - 2020 Shu-Hung You Hall of fame 2019
2018 - 2019 Vijay Kandiah and Chenqi Guo Hall of fame 2018
2017 - 2018 Matt C. Cheung Hall of fame 2017
2016 - 2017 Zhiping Xiu Hall of fame 2016


Next is the evaluation of this class done by its students.
Ratings are between 1 (lowest) and 6 (highest). NA = Not Available

Year Number of students Teacher Course Amount learned Intellectual challenge Stimulating interest
2023 - 2024 41 5.77 5.42 5.43 5.57 5.67
2022 - 2023 42 5.84 5.44 5.50 5.50 5.74
2021 - 2022 30 5.92 5.79 5.79 5.64 5.93
2020 - 2021 21 5.88 5.78 5.89 5.78 5.88
2019 - 2020 28 5.83 5.61 5.78 5.72 5.83
2018 - 2019 32 5.45 5.18 5.23 5.55 5.33
2017 - 2018 18 5.91 5.55 5.82 5.82 5.91
2016 - 2017 20 5.82 5.64 5.55 5.55 5.82
2015 - 2016 14 5.67 5.60 5.80 5.20 NA
Average 27.33 5.79 5.56 5.64 5.59 5.64
Total 246

Next are all the comments about the class directly from its students. No filtering is performed among the comments. The next comments are the answers to the question "Did the course help you learn? Why or why not?"

2023 - 2024

Two things you need to know 1. you need to have a lot of time on your hands for this class. you are writing a new sub–compiler every week, and each of those assignments takes average 20 hours of work, varying a little based on how good at coding you are. but even the smartest folks in this class, the grad students who have taken compilers classes before and know how to use macros and other fancy stuff, even they average at least 15 hours per week. i've seen people spend 35+ hours on a single assignment and still aren't able to complete it. you have to write so much code that, if you don't enjoy coding itself, you may well get sick of writing/looking at code. 2. if you have the time and spend it on this class, you will learn so much in such a short amount of time. you will learn more per minute spent on this class than any other class in the entire CS curriculum. not only will you have with an extensive understanding of how compilers work, but you will also leave the class with a ton of practice with advanced object oriented programming concepts and techniques, practice working with large codebases, and knowledge about how to design and implement complex ideas in code. you will become a MUCH better programmer all around. these skills are widely applicable to any industry field; the knowledge you gain is incredibly useful even if you aren't going to specialize in compilers in your career. Grading is very very fair. If you spend 20 hrs/week on this class, and you give a genuine effort in the assignments to not write disgusting code (ie. you put thought into the design of your code and it makes sense for the problem you're trying to solve), you'll get an A. The biggest drawback of the class is that there is not a lot of help and support available if you need additional help. This class is managed only by Simone and one TA Brian. There are no PMs. This means there aren't a lot of office hours and piazza questions take forever to get answers to. This class relies heavily on your own debugging skills and forming groups with other students to help each other out. In most CS classes, if you're stuck, there is a large support system. In this class, if you're stuck, its pretty much up to you to unstuck yourself.
Oh boy here we go... This entire quarter was dedicated to compilers. I spent basically 0 time in other classes. Please do not take this class with any other homework intensive course you will be extremely miserable. I came into the class with minimal C++ experience and the pace at which you can complete this course is going to be much slower than most of the class if you don't have experience with compilers/LLVM/low level design. Also helps if you've done SWE work in the past (in my case i've interned twice and it helped a lot and still I was extremely bed in in the course most of the quarter and was always playing catchup). I usually sleep before 12 but I was probably up until 2:30–4 AM everyday in mudd this quarter and woke up by like 9 or 10 to get back to work. In any case it's pretty life consuming. However, to be perfectly honest, this has also been the most rewarding class I've ever taken. In essence Compilers is teaching you how to build a compiler from scratch...but it's really just a large scale software project where you have some guidance to build it. You learn a ton about how to REALLY design OOP projects and also how to write manageable code (I used to think this was just being diligent about naming and typing etc but it's actually really difficult). The lectures are extremely useful and are all you need to know what to do for the homework. There are a lot of algorithms that you can literally implement directly from the slides, but don't be fooled, you need to understand how and why everything ties together in order to implement it correctly. I'm a big believer in challenging yourself in college so if you really want to learn and grow this is the class for you. I am so much better as a software engineer now and i'm excited about continuing to grow.
Unless you are really skilled, this class is a test of will. Everything said about the past CTECs are true and more; this class truly is a massive timesink that you have to plan around. Knowledge of C++ is pretty much required, and it helps to have a partner in mind walking in as well. This isn't a class to be taken lightly, and it's definitely not for everyone. That said, I found this class to be one of the best made in the entire CS curriculum. – Most of the policies are very fair towards the students; there are no late policies because you can turn the compilers in whenever you finish them, but you are rewarded with a chance to get an extra point through a panel if you do turn it in on time. If you turn everything in at the end and it all works without a hitch, you are guaranteed to get at least a B+ in the class. – The above point means that there is still value in pushing and struggling through all the way if you are determined to, because – You learn so much about software engineering as a whole as well as compilers. Most of the materials that the professor gives you are relevant; he gives you an algorithm, and it's up to you as the programmer to find a good and maintainable implementation. You directly experience the saying "you reap what you sow", as each compiler builds on top of each other (very often you will copy paste code from your previous assignments). – The professor cares about what he's teaching. His lectures make sense and are natural to follow. Again, this class is a massive timesink. You will suffer a lot unless you are a programming genius. It's completely understandable if you end up dropping in the middle. But the best way to learn is unfortunately by suffering.
This course was definitely my favorite (and the most well designed) course that I've taken so far. The overall goal of this course is to take a high–level C–like language and build a compiler capable of compiling it down into assembly. You start off by writing a compiler to translate a language very similar to assembly into proper x86–64 assembly. (Almost) every week, you are taught a new language that adds a new abstraction, and your homework is to write a compiler which translates the new language into the one learned in the previous week. Simone has done a really good job chunking up the compilation pipeline into very digestible pieces, and its really cool how you implement a lot of features that are used in real production compilers. As you can probably tell from the CTECs, this course requires a LOT of time. Most people say this course takes 15+ hours per week and that doesn't count the good percentage of people who dropped the course. Compilers are very complex by nature so assignments take a long time to code. You are also not given explicit instructions on how to implement homeworks so you are responsible for making significant design choices (and you'll also suffer the consequences if you make bad choices). This class also only has one TA so office hours and piazza responses are fairly limited, so you won't be able to get much help with things like debugging. While this course is great, I think you should only take it if you have the time AND you have some confidence in your ability to code and debug independently.
PREPARE FOR THIS COURSE TO BE YOUR LIFE FOR AT LEAST SIX WEEKS Assignments are weekly, and the first 5 took 12–20 hours each (and I was working with a partner). I cannot emphasize how important it is that you prepare for this reality. Once you've accepted the time commitment, the course is absolutely fantastic. Simone is one of those lecturers that is clearly wicked smart and knowledgeable but is even more passionate about the course material. He has very high expectations for the students in this course, but makes it clear that it's his priority to make sure you can meet them. The course layout is interesting: there's no exams, just 9 weekly compiler programming assignments (plus coding some tests in the target languages). The course is much more difficult in the first 2/3s (difficulty probably peaks around week 5) and drops off pretty quick to being probably easier than most other systems class in the last few homeworks. You're done by the beginning of reading week, which is very nice. You will do so so much C++ programming, and Simone teaches a lot of good code practice and software engineering patterns that are useful to know in general, so the class is great at advancing your C++ ability independent of compilers. Would strongly recommend this to anyone somewhat systems–oriented and looking to challenge themselves!!
This is one of the best courses I have taken at Northwestern. However, none of the CTECs are exaggerating when it comes to the workload. Be ready to spend ~20 hours a week on this class for the first 2/3rds of the quarter. Professor Camapanoni understands that students are taking other classes as well, so the most time consuming and intellectually challenging assignments are given out early on and the last few weeks are pretty trivial. I definitely recommend reviewing and learning more about C++ before the quarter starts; 211 is insufficient. Besides that, you will have the unique opportunity to work on basically a quarter–long project and feel immense satisfaction whenever your compilers finally pass all the test suites and participate in a class–wide competition. Take this class even if you are on the fence! Professor Campanoni truly cares about the course and puts in an insane amount of time and effort into the student experience.
This class is a LOT, and Simone knows it. Be prepared to code for pretty much the entire weekend and then some every week until like week 6. Class eases out a bit after that, as in you’ll probably finish on Monday/Sunday instead of Tuesday/Wednesday. Basically, each week you build a compiler from one language Simone designed to another. You build up from outputting assembly to by the end of the quarter basically taking c code as input. The class is extremely well designed, and you will learn so much software engineering skills, as long as you are willing to put in/have the time. If you have the time, you’re basically guaranteed an A. Probably the most valuable CS class I’ve taken so far at NU, was rough but absolutely worth it. Oh, and Simone is wonderful just as a person. He cares so much about your learning, more so than anything.
The course is pretty cool, but depending on your level of perfectionism, might take up all of your time. The actual content of the class is not that difficult and is important to know if you want to know anything about compilers at all, but the main struggle is the homework assignments. Part of your grade comes from how many "panel" participations you get, which is basically one opportunity per assignment for your code to be deemed good enough to present to the rest of the class. Even if you don't get a single one of those points, you can still get an A because he gives extra credit assignments at the end.
This class definitely pushes harder than most of the others at NU, and the drop ratio reflects that. You really do learn a lot about compilers, and I would recommend it to anyone. Myself and my partner went into the class with a good amount of prior experience in Software and C++, so we didn't find the programming assignments too demanding – more just tedious. I think the difficulty is a little bit overrated, unless you are trying to win the contest. Take the class! You will learn!
This was by far the best class I've ever taken in my life. I've never been one to attend class regularly, but this class is one that I would be excited to attend each time every week. Simone was super passionate and knowledgeable about the subject, and the structure of the course and the slides were outstanding. However, the class does take up a lot of time and requires some basic C++ experience. If you have the time, I highly recommend taking this class.
Simone's passion for and knowledge of the subject matter is apparent from day 1 and is what makes the workload bearable (there may be some Stockholm syndrome going on). I have never seen an instructor so dedicated to a course; he's put so much time, effort, and thought into designing the course from the layout to the code framework to the slides to DESIGNING CUSTOM LANGUAGES AND ALGORITHMS to fit the class schedule. Just a fantastic professor.
This class demystifies the secrets behind the common compilers we use every day. So it is a decent class to take for anyone interested in this topic. The assignments provide good opportunity to gain hands–on experience for compiler engineering. However they are very time consuming, and a large portion of it is writing parsers, which is repetitive and boring towards later parts of the class.
Amazing class. It takes tons of work (around 20 hours a week) to get everything done, but by the end it's all worth it. Compilers are seriously cool pieces of software and you get a really deep sense of appreciation of how they work after building one from scratch. A side effect of this course is that your software engineering skills will go through the roof, and that's a promise.
The course was so densely packed with information I think it would be impossible to not learn something even if you'd already taken it. On top of that, Simone is a great lecturer and is very happy to answer questions and go on tangents. I felt like I picked up a lot of software engineering / good code practices on top of the compiler content, which is amazing.
Amazing at teaching and designing courses. One of the few professors that I've had at Northwestern who is both an expert in their field and extremely dedicated to teaching. Very refreshing to see how seriously he takes student feedback and how much he works to iterate and improve his courses.
This course is a lot of work. Do not take if you do not want your life to revolve around it. Also do not take if you are not comfortable making relatively large projects in C++. This is class you take if you want to challenge yourself. It was probably the hardest CS course I've ever taken.
Sort of. I drowned in the assignments quickly and did not have much time to understand the concepts at work for the rest of the quarter. I don't feel like I came away with any good software engineering skills or experience either – I think these were expected before taking the class.
It helped a lot, and I learned them by following assignments and building compilers from scratch. Not only compiler related topics, it also helped (forced) me learning better software engineering principles, so the future me working on next assignments won't punch me.
Lectures covered everything you needed to be able to complete assignments. Panels, especially Simone’s, were super useful to learn about software engineering patterns and to understand how to best design the thousands of lines of code we wrote each week.
Designing the class to be challenging, engaging, and teaching software engineering skills alongside compilers stuff. Being a super kind, supportive person and really focusing on communicating ideas and making the class a learning experience for everyone.
This course was an insane amount of work. If you don't have a very solid base in c++, it becomes even more of a time suck – it's also extremely important not to fall behind. It's very likely your other classes will suffer so be smart with scheduling.
I learned so much from this course. Not just about compilers and how they work, but also about OOP and C++. I became a much much better programmer overall. The lectures were fantastic and assignments pushed me to be a better programmer.
Great course with a lot about compilers to learn about except that the pace of the class is a little bit too fast at the beginning. It will be nice to have some buffer to keep up with the class say a two week assignment at the beginning.
I will say there is very little help in this class (2 OH and a bit of time b4 and after class to ask simone questions) –> make sure you choose a good partner because y'all are gonna be in the trenches together all quarter
the first reaction to those difficult and time–consuming homework is depression and burnout for sure. But by pushing myself to learn more and try to finishing those code, I can see my personal growth afterward.
This course helped me learnt a lot of the construction of compilers. It basically tells you the algorithms and mechanisms under the hood of compilers, layer by layer. Learnt a lot from this class.
This course helped me learnt a lot of the construction of compilers. It basically tells you the algorithms and mechanisms under the hood of compilers, layer by layer. Learnt a lot from this class.
This course helped me learn a ton about not only compiler concepts, but also useful patterns such as the Visitor Pattern and Singletons. It also made me so much more proficient with C++.
Yes! This course taught me the back–end process of compilation, which is something I had never done before. Simone is an excellent lecturer and answers all questions is great depth.
Really time consuming, but made me better at designing C++ programs in general. Compilers were very unexpectedly cool. If you have the time and grit you should take this course
I think I got a pretty clear understanding of how compiler works after taking this class since we basically build one that seems to be close to modern compiler from scratch.
This class is a lot of work. Many elements have been simplified to make it more reasonable, but it remains unreasonable. It is an important thing to learn though.
It taught me some stuff but wasn't very focused on that because the majority of the time was spent debugging the parser that we needed to rebuild every week
The pedagogy (instruction, grading) in this course is fantastic; this has been the most productive course I have taken at Northwestern thus far
Yes. The homework assignments provide a lot of hands–on experience to the fundamental concepts and algorithms of compiler front/back–ends.
Building compilers from scratch really helped me learn about how compilers work and the concepts behind each design decision.
Yes, by doing a lot of coding, I learned the concepts of the compilers and also improve my engineering capability
Yes, we covered some fundamental topics in compilers and the homework assignments helped me put it into practice.
The course really puts you to the test, both in terms of work ethic and intellectually.
Good course, A little bit cramped of work. There are no breaks between assignments
The survivorship bias is real in this one. CTECs should provide the drop rate.
I think I had too much prior SWE experience to gain as much as some people.
Yes, there’s no better teacher than just doing the thing
It's a lot of work, but it's definitely worth taking.
I had a positive reaction to this course
Yes, it helped with SE principles
Yes. Professor was great.

2022 - 2023

WORDS DO NOT DESCRIBE HOW GOOD OF A CLASS THIS IS! Simone is such a great teacher. He loves the material, and every day he comes in you can tell he's just excited to talk about compilers. The class is structured in such a way that there are no exams or midterms, simply homework assignments where you demonstrate your knowledge of the material. That does not mean this is an easy class, though. You will be working. A LOT. Do NOT take this class with any other homework–heavy class (i.e., OS, networking, etc.). But at the end, when you look and see C–like code going in and assembly going out, you realize how much you've accomplished and learned. It's extremely rewarding. This class is also special in that you don't just learn the material. You also gain experience working on a large software project from scratch. You learn about common design patterns in computer programming. You don't just learn algorithms, you implement them in a real world use case. And you get the opportunity to give a code walk or take place in code review.
It is the most challenging course I have ever taken. In addition, it takes a lot of time: I worked for about 35h a week and still struggle, so it probably takes as much time as two/three "normal" courses. You will have great difficulties if you do not know advanced c++. There is too much homework, and it is challenging to follow the course up to date. I work intensively in this course and still struggle to submit homework on time. On the positive side, the Professor is competent, intelligent, and organized. You get to learn a lot during the course.
This class was my best worst decision tbh. Simone is a GOAT. He designed this class super well, and coming out of it, I am a much more confident developer. I don't think any other CS classes I've taken has made me develop so much. It's not that I'm super interested in programming languages or compilers, but learning about how they work and building one was just super cool. Simone paced the course very well and I don't think there is a better compiler class in other colleges than Simone's, which is rare to say (unfortunately) for NU.
Easily the most time–consuming and hardest CS class. Prof. Campanoni is very passionate about compilers, an excellent teacher, and cares a lot about the course. Take it just to prove to yourself that you can survive through it: no one can call themselves a good programmer without having gone through a course about compilers; it is the rite of passage.
For those who are interested in compiler and want to do related research, this course is a perfect choice. But it is not suitable for those who just want to get the grade. The assignments may take almost 20 hours per week. You need to work very hard to eliminate the potential bugs in your implementation, and your work is totally worthy.
That's the best project course at NU. Sure, it will take quite some time, but you learn a lot, and build an actual compiler. Simone's lectures are great, but don't procrastinate after them! Concepts are not that hard, but it will take some time depending on your skill level to make them work efficiently.
CS322 CC helps me have a deeper understanding about how compilers work through well–designed assignments. These practical experiences enable me to become a more advanced compiler developer.
This is a fantastic class. It is a lot of work, but it is equally rewarding! Professor Campanoni is also amazing and I would recommend all his classes.
This class will turn you into an experienced C++ programmer and teach you so many important computer science concepts.
YES THIS CLASS WAS AMAZING! The teaching style allows you to demonstrate your knowledge and get feedback on your code.
Yes. The class is well structured and the professor put in a lot of time and effort to design the course
Simone is GOATed with the sauce. Really great lecturer. Be wary though. Most time consuming class EVER.
The challenge was there for sure, I wanted to learn and be challenged and that's exactly what happened
yea class is a bunch of work. did it tho. you WILL learn.
Figure out visitor patterns before you take this.
A lot of work, but definitely worth the effort.
One of the best courses I have ever had.
yes. homework make me learn.
Yes, simone's great!

2021 - 2022

This class is amazing and I truly recommend it along with Simone's other course CS323: CAT. Yes, it WILL be time–consuming and will certainly take 20+ hours a week, but those hours are well worth it at the beginning of the quarter to have little work at the end. Having experience with C++ (ie defining classes and using std::map, vector, and set data structures) and GDB for debugging really helps. Also, this class heavily relies on good design and SE practices (such as visitor pattern, simple + understandable + efficient data structures, modularizing your code, etc). You (with a partner) will build a compiler from the bottom up by going from x86–64 assembly to increasingly C–like languages. The structure of the assignments is this: 1) Simone presents a new language, which is based on the previous week's language *with additional features*. You must understand the week's language from the perspective of a developer by writing some test programs in that language. 2) there are 1+ lectures on how to implement the compiler for that language by *lowering* the additional features into the target language. Simone's teaching style here is just awesome: he really explains and shows examples for literally every part of the algorithm s.t. there is no ambiguity – you have the complete information for how to build the compiler (unlike in CAT where you had to be inventive) – so your task is just to understand that and design your code well. Your grade is based on a combination of panels and homework. When you submit a (correct) homework on time, you have the opportunity to be selected for a panel to either present your code or review others. Other than getting enough panel experiences, you can submit assignments late for full credit, so you can kind of pace yourself in this course. Along with Simone's other policy where you can "skip" difficult assignments by implementing trivial code, you be flexible about assignment submissions to get your desired grade and focus on whichever assignments you want to truly understand. If you enjoy systems or programming languages I strongly advise you to take this class, it's amazing!
This class is a lot! Every week you build a new compiler with each compiler building on the previous ones (so you have to finish previous compilers to move on). Unlike other CS classes where you probably have the boilerplate code given to you, here, after the first compiler you pretty much make everything from scratch. Though, you can often copy over large parts of the previous compiler's code or make appropriate changes and you get a feel for things after the first few compilers. That isn't to say it gets any easier though. Especially around the middle of the quarter, the complexity really ramps up (and Simone will tell you this). In addition to the compilers, if you finish before the deadline for each compiler, you can be on a panel where you show how your code works. These were always interesting to watch. However, in order to meet the deadline each week, my partner and I pulled several all–nighters often despite having been working on it for several days already. Depending on how fast you work, each compiler can easily take over 20 hours to complete. For us, it took about 2–3 full days of work every week. I definitely recommend taking this on a quarter that is otherwise relatively light since this class's workload is basically 2–3 classes worth of work on its own. With all that said, if you have an interest in compilers or want to gain programming experience (especially in C++) then I highly recommend it. You'll get pretty familiar with C++ and get to use/implement several data structures and algorithms and get better at problem solving along the way
Extremely helpful course for CS. Helps teach you how to make sustainable and optimized code. However this class is such a huge time commitment, it probably singlehandedly doubled the amount of code I've written in my lifetime. Come into this course with someone you know because chances are, you'll be spending more time with them than without. I loved this course, but I really underestimated the amount of time that it would take (even from looking at the ctecs). If you don't think you'll have time to dedicate every waking hour to this course, I wouldn't recommend taking it. It was probably one of the most rewarding and enriching CS courses I've taken, but it was very difficult to maintain a social life with the deadlines you had to meet.
This is definitely a worthwhile class, but the homeworks took so long. Like, if I could go above "20 or more" on the CTEC thing, I absolutely would. The actual concepts aren't too difficult, but it will take up all your free time. The CTECS are not wrong at all. However, it's super worthwhile. I've definitely improved as a programmer and my C++ skills have had a massive boost. Some of the CTECS from before this year are super weird though. You're not gonna feel like a god or anything. It was in some ways fun to put everything together though. Only take this class in a quarter where your other classes are easy. I pretty much used my other 3 as study halls for this one.
This course will take up A LOT of your time. On the heaviest weeks I probably spent over 40 hours working with my partner. DO NOT take this class while taking any other class that has a large work load or that you care about devoting a lot of time to. Despite the incredibly work load, I found the material pretty interesting. Although my interest in the material did not justify the heinous amount of work the assignments required. If you are an experienced C++ programmer, you'll likely have a better experience than me, whose only experience came from CS 211. I definitely learned a lot though, and this class will hopefully make other CS courses feel easier.
Yes, the course helped me learn! The professor was very patient and ensured he explained everything without assuming background. Also if you are interested in Software Engineering and learning how to manage and extend large systems, this might be a good introduction. The professor gives you guidelines weekly that enable you to go back and restructure your codebase to be better, or even use whatever principles you learn in your next assignment.
The class is an interesting class. Though it require lots of dedication and commitment to the projects, it is really rewarding. You need a competent partner who is willing to spend lots of hours together working on the project. The Instructor (Simone) is super good that all you need to success is explained in the class.
yes, i learnt so much about how to built the frontend and backend of compilers and i was able to build a compiler that encompasses the backend and frontend
I learned a lot in this course. The curriculum was all new to me and I had to learn a lot of programming skills independently to complete the assignments.
This course will teach you so many design patterns and techniques for coding that are useful in far more contexts than compilers.
Yes, the course helped me learn! The professor was very patient and ensured he explained everything without assuming background.
I'm surprised that compilers can be broken down in to many mini compilers and each of them focusing on one topic of compiler.
Simone's teaching style of showing by example and motivating stuff during lecture is really superb
Yes, a huge amount
Yes, a lot

2020 - 2021

This class is HARD. The first week, you have to create a compiler. The basic principles behind the compiler are given to you, but in terms of the practical application of those concepts? Up to you to figure out how to do that. You'll feel like a god, but you'll also be spending most of your free time on this class, especially in the middle of the quarter. It's great that the class is structured such that the hardest parts of it are in the middle of the quarter, rather than at the end, but that means your weeks 4–7 will be quite a mess of working on this class every spare minute that you have. Overall, though, I highly recommend it. I don't know if I've ever learned more in a Northwestern class.
This class is very good. In addition to content differences, I find this class focuses more on implementation/design of compilers than 323. It does a very good job––it is the first class I've taken that's made me appreciate good design. Try to make sure that you have a good partner––it does make a huge difference and having a good partner really reduces your stress for this class. I'd recommend that you try to devote a little more time to this class than necessary. If you can spend more time on this class than just the time it takes you to do assignments, you'll get a lot more out of it. But the assignments do take some time.
CS322 is one of the most demanding yet most rewarding 300–level CS courses. The ideas discussed in class are not extremely challenging, but you'll learn quite a bit since implementing/debugging them in C++ as part of your own compiler forces you to understand them far more deeply than you otherwise would. It also requires a *lot* of time, but it does make you a better software engineer. Simone is an excellent instructor and the material is very well organized and presented.
This class is time consuming, can be quite difficult, but totally worth it. Simone does an awesome job in designing this class for maximum learning in minimum amount of time. You get a build a compiler from scratch, but don't let that be too intimidating, Simone guides you through a new part of the compiler each week in weekly assignments. You also get to learn some new design patterns and good coding practices along the way. Great class, definitely a must–take at NU
Absolutely incredible course in terms of hands–on experience. Just asking students to build a compiler knowing only the basic principles behind them? Wonderful. Really makes you feel inventive and like you've created something you can be proud of.
This course is tough but worth it. You will become a much better software developer through making your own design decisions every week. In addition, it is very satisfying to be able to say you've built a compiler by the end of the course.
One of the best courses offered at NU. It's not too difficult but perhaps one that consumes a lot of your time. It is nevertheless worth it as you learn a lot not only in terms of compilation but also jsut good SE practices in general
This class is a dictionary example of learning by doing. There is a whole lot of doing, but there is enough learning that comes with it as well. There were some logistics hiccups that could be improved, but otherwise a great class.
Great class. Hard, but certainly worth it. I suggest taking it with an easy schedule or else you will submit code that you are not particularly proud of and that you wish you could have spent more time with.
This is the best course I've taken at Northwestern. I had a ton of fun optimizing my compiler for the final competition. I highly recommend you take this and Simone's other class CAT.
Great class. Simone is the best professor I've had the pleasure of learning from at Northwestern. The difficulty of the class peaks in the middle of the quarter, so plan accordingly.
This course was the single most impactful educational experience I've had to date, largely thanks to Simone's commitment to designing it as effectively as possible
I really enjoyed bottom to top approach approach. The idea of increasing homework complexity in the middle of quarter instead of the end is just brilliant
Not only did I learn about basic principles in compiler consturction, I have also learned a great deal in software development and design principles.
The assignments build upon one another which allows to build up a understanding of the area while gaining expertise on individual subject areas.
This course helped me learn how to take complex compiling processes, and make it in a step by step procedure that I could implement.
Yes, the incremental development of the assignments allowed me to learn the individual concepts within the context of the area.
Heavy load but you learn a lot. A lot of work but not you can get an A if you pay the efforts. Simone is a nice guy.
Yes. The assignments were challenging, the structure of the class was very motivating, and lectures were engaging.
Yes I learned a lot. The course gives a flavor of how algorithms can solve really complex compiler problems
Lectures are very solid but leave enough implementations details to the student for it to be interesting.
Yes. The hands on experience implementing a relatively large project was a huge learning experience.
Yes, assignments and gamified grading were excellent
100%. It explains complier by building a compiler.

2019 - 2020

This course was by far one of the best courses I've taken in my entire life of being a student. I would absolutely recommend anyone who is even remotely interested to take it. The professor: Simone is a rare professor that is good at what he does, and also is genuinely interested in teaching. His lectures are really clear and informative, and he is very approachable after class/in office hours if you have more questions. The content: I thought that the subject was really interesting, despite not really knowing anything about compilers going in. You obviously learn a ton about compilers, but also some low–level machine representation stuff, software development principles, and more. You will become a much better software engineer after taking this class. The work: You've probably heard this course a ton of work. This is true. Particularly, each homework builds off the last one, so make sure you do a good job on the first few otherwise you will have truly insane bugs later on. One nice thing is that Simone spreads out the work so that its easiest at the end when all your other classes are hard. Still, don't take this in a heavy quarter. Also, make sure you're solid on C++ because you'll be writing a ton of it. All that being said, the work is hard but its really interesting, and not many people can say they've built a full compiler from scratch
This is a fantastic class. If you are interested in the subject, and are taking an otherwise easy quarter, I highly recommend this course. The numbers are not lying: you will work for on average 20+ hours a week, sometimes less, sometimes way more. But I learned more in this class than any other, not just about compilers but just generally about software engineering. Writing a codebase from scratch across a whole quarter is really rewarding. Both Simone and the TA are fantastic, and Simone's assignment framework is the best I've seen. If you are up for the challenge and want to learn a ton, take this class. Also, the nice thing about this classes is that it ramps up around weeks 3–7 and then cools off a ton. When your other classes start ramping up weeks 8–11 you will appreciate this. This is also one of those "do all the work and you will definitely get an A" classes, with no exams, but the shear amount of work balances that out and makes it a challenge.
This course is a lot of coding. A whole lot of coding. The algorithms really arent' hard, and Simone gives you a lot to work with, but you need to be prepared. Also, while I did learn about how compilers work in this class, I think I learned more about designing and constructing software, because each compiler you write you write almost from scratch, so you have to think about the data representations and how you can structure your code to be easily changable and maintainable, but also to enable working with the algorithms for each compiler.
The course structured the knowledge of compiler construction in an incremental way that makes it easy to focus on important concepts in individual topics, without the need to grasp the entire subject at once. The concepts are well–explained through the lectures. The homework breaks down compiler back–ends into separate pieces, dramatically reducing the complexity to the degree that building a remarkable portion of back–ends is possible within 5 weeks. The course load is heavy but worth it.
Yes. The course structured compiler construction knowledge in an incremental way that makes it easy to focus on important concepts in individual topics, without the need to grasp the entire subject at once. The homework breaks down compiler back–ends into separate pieces, dramatically reducing the complexity to the degree that building a remarkable portion of back–ends is possible within 5 weeks.
Best course at NU. You learn SO MUCH and create a working compiler by the end but that being said, it's a lot of work. The workload is worth it though, Simone is a great professor and you will learn more in this class than any other CS class at Northwestern.
Very hard course, but the difficulty is worth it. You learn a ton throughout the quarter. I recommend taking this class if you have an easy quarter and you want to become a much better C++ programmer.
Absolutely. The lectures were very clear and explained difficult concepts very well. The amount of hands–on learning was fantastic. I think I learned more in this class than many other combined.
Yes, the way Simone structured the material really emphasized the parts of the course that helped me learn a lot, and mostly minimized the time I spent on less educational things.
This course was a ton of work, but I learned a lot and am happy I took it. My only complaint would be the few available office hours and their odd times.
The design of this course is very helpful to develop basic coding styles. It helps outside of this course as a programmer in general.
A lot of topics and a lot of code to learn by doing. Learned so much and actually have a cool project that im proud of.
This course's content was straightforward and easy to understand. The challenge was in the coding.
It helps not only about compiler, but more on elegant coding styles and design strategies.
Yes, the work was extremely open–ended but lots of support was given in the framework.
Everything in this course is just perfect. Not for the faint of heart though.
This is an awesome course. Arguably the best course in CS.
I learned more in this course than in any other.
Yes. A great and systematic course.
This class made me a better coder.

2018 - 2019

Simone definitely cares about presenting a great class to students. Unlike many other CS classes, where there are issues with starter code or the autograder isn't working, Simone's framework, which is all the starter code (tests included) he gives at the start of the quarter really lets you focus on the compiler you're creating. If there is an error, he or the TA is quick to fix it and push out a new framework. Content–wise, I was pleased for the most part with what was presented. It definitely was not easy stuff, but it's worth learning for the most part. While it isn't said to be such, this is a class that has a heavy software development flavor to it. If you don't design your compiler well early on, it will come back to bite you hard later. Simone definitely emphasizes good design, and I learned a lot about C++ design as well. My one issue was the fact that we didn't cover a few things I thought would be integral to compilers such as parsing. While we use an open–source parsing library (and it makes sense to do so as creating our own parser from scratch would be super overwhelming with the rest of the assignments given), it would have been nice to learn some parsing theory.
This is probably my favorite CS class that I've taken at NU so far, and Simone is a fantastic teacher. It is an extremely rewarding and enriching class that I would highly recommend every CS major take before they graduate. You will work a lot, but you will also learn a lot, and you'll be able to end the class feeling really proud of what you accomplished. My one piece of advice is to not take this with any other time intensive classes. Please, please, please take this when you have an otherwise light quarter. The assignments are *very* substantial and also paced rapidly (sometimes you have less than a week). But keep in mind that it's not busy work, and I'd argue that in order for the class to function like it wants to, this amount of work is necessary. You'll learn a lot about compilers but also good software engineering practices. The structure of the class, which has built–in things like in–class code reviews, is built around you growing as an engineer. I promise that if you take this class when you have the ability to dedicate the time, you won't regret a second of it.
This is a very good course to learn how a compiler is formed and how a lot of features in the advanced programming languages you wrote are tackled and realized through building a compiler by yourself. This is a bottom–up introduction and engineering course in compilers, which, is inverse to most of the top–down approach in compiler education I've ever heard of or seen. It's also a good course to train your ability to write code in C++14 using features such as STL. You will be amazed and feeling a sense of achievement when you build up a C–like language compiler in the end. The final competition is full of fun, the best team or student will come to the full of the frame on Professor's personal page. Be prepared to spend a lot of time on this course and prepare even more time on this course if you do more optimization and want to win the competition!
A fantastic adventure through the land of complier–topia. Our journey begins in the depths of the Assembly .S(wamp), but once we have passed the navel at the center of the world we ascend to the .b(eautiful) verdant fields of C–like syntax. Did I mention that you write the entire compiler by yourself? This class is a ton of work, but there is a real sense of pride and accomplishment at the end when you can compile and run a program using only* the tools you wrote. Simone has put a lot of effort into making each homework as impactful as possible, so while you will be busy you will also learn a lot along the way. *Terms and conditions apply, linker and assembler void where prohibited.
You have been my favorite professor so far without anyone else coming close! You are very engaging during class and made coming to office hours inviting because of how genuinely nice you were and how much you cared about the subject. The simple fact that you enjoyed when students found bugs in your code showed how much we value the student improvement over your ego: a quality I unfortunately don't find in many. The fact that I walked out of the last class with a huge smile on my face having to tell the whole class my compiler was the worst is solely because of the amazing way you taught the class so people wouldn't feel bad if they struggled with a difficult topic.
This course was weird. It felt like it wanted to be like 321 but failed. During the class, we learned the algorithms used to solve certain problems in compiler construction but the algorithms weren't explained in a clear and detailed manner, explicitly comparing it to the garbage collection class in 321. Then for the homework we were asked to implement the algorithms, but that was also a low quality experience. The framework was buggy all the time and since it could only be run on school servers, we couldn't use an effective IDE to debug and instead had to rely on print statements and –very unfortunately– gdb. This course needs some serious improvements.
Is this class my favorite CS class so far: yes. Is this class my hardest CS class so far: also yes. Even though this class will have you spending more time on it than probably any other, the work being done during that time is fulfilling as it challenges you to come up with your own strategies to actual problems. Simone is also an absolute legend of a professor and any class taught by such an understanding, nice, and enlightening person as him is worth it. At the beginning of the quarter, I was questioning if it was worthing taking such a difficult subject, but now with it behind me, I couldn't be more satisfied.
Warning: this class is hard! But I would say worth it. The whole premise is you're making a compiler yourself from the ground up and each homework builds on the last so it's important to stay on top of the assignments. That being said, Simone is really good about explaining the ideas you need to implement and gives you alternatives to the ideas that are harder to implement. Very interesting class and I learned a lot!
As a graduate student, I cannot spend all my time on classes. This class is particularly more demanding than any other class. The worst part is that I cannot choose the dedication I want to put into this course. I couldn't do that for two reasons; every homework is stack on top of previous homework and professor wants us do pair programming.
He knows a LOT about compilers. I don't think there was a single question in class that he was not able to answer. He knows how he's asking us to build our compilers and how industrial strength compilers tackle similar problems and is good at explaining the pros and cons to compiler design decisions.
Yes, especially by forcing me to implement the various features of a compiler we discussed in class. I would have appreciated a little more focus on the development of algorithms & abstractions as opposed to the less interesting bits like parsing.
This class was very, very time consuming. Pros were that Simone is an excellent professor, and class focused on code design, not just compilers. The first couple weeks require ~20 hours of week, but work ramps down by the last 3 weeks or so.
This class pushed me to learn about compilers by making one myself. I think the "learn by doing" methodology gave me a deeper understanding and appreciation for everything that goes into compiler construction
Great course but this might be one of the most time–consuming courses at NU. Debugging can take hours and often times, bugs are hard to find because of the nature of parsing.
Very patient and kind. Really just a lovely person, very pleasant to talk to, always willing to answer questions, is clearly very passionate about the material. Good lecturer.
This course helped me learning the basics of the compiler. However, it was too demanding to do everything I was asked to do correctly.
I definitely learned a lot but some of the assignments required a lot of time debugging and so the learning value seemed to diminish.
Yes this course teaches me how a compiler is formed and I really enjoy writing codes for building compilers.
Yes – the projects were effective in teaching us the concepts and practicing good programming habits.
Letting student build a real compiler of their own instead of teaching too many theories.
This class is very hard but it gets a little repetitive after the first few weeks.
The professor was certainly on top of his game. He facilitated learning greatly.
yes, challenging material, lots of coding, forces you to think about the code
Yes, I felt I learned a lot about C++, compilers, and software development.
He is passionate in teaching and actually teaching the subject well.
very passionate, available for office hours, well structured course
Great course focusing on development of real working compilers.
Well–organized, interested in the class and the students
Very organized, explained complex topics well.
great course, teaches you to code
Engaged and knowledgeable.
Fun course 10/10.

2017 - 2018

Certainly forced me to learn a lot about C++, just by virtue of the fact that for this course, I probably wrote at least 4x as much code as for my second most work-intensive class. Simone also taught us a lot about design and helped me refine my design/implementation process, and just generally taught us a lot about how to think about programming. Really enforced the importance of good abstractions. Additionally, Simone did a great job of going in depth about several aspects of compiler back ends and compiler middle ends. I learned a ton.
Definitely hardest CS class (maybe excluding algorithms). If you have the time for this class, you will learn more than any other class you can take at this school. Don't take any other work intensive classes in the same quarter. Expect to spend 20+ hours per week on homeworks. Simone is amazing and is trying really hard to lessen the workload year to year. Make sure you have a good partner, because you'll be spending a lot of time together.
Simone is a great instructor and truly cares about his students' learning. This course was definitely one of the most challenging courses -- mainly due to the amount of freedom you have in implementing your compiler and the rigor of the deadlines/timeline he expects us to meet. If you enjoy programming languages and want to understand how everything works under the hood, you should take this course.
Simone is a great instructor who actually cares about his students learning. The course was incredibly challenging, but Simone was there to help. This class is more about general programming design than compilers. At times, it was frustrating because we just didn't know where to turn and the slides could be a little vague. I would recommend this class to anyone.
Will definitely learn useful skills on building a compiler as well as programming with C++. You may need a good C++ partner before taking this course.
I highly recommend students who are at junior level and above in CS major take this class. It is gonna be time- consuming. But you will learn a lot.
Though I need to cost more than two days per week in this course. This course is fantastic.
Yes. I learned a lot from the professor on how to write clean and beautiful code.

2016 - 2017

I highly recommend taking this course with Professor Campanoni. He's really interested in helping students and so you end up learning a lot in this class about both compilers and good programming practices. I was a little skeptical about the panel format at the beginning, but it's a great way to understand each part of the compiler by having people defend and challenge the code of others. In the process, you get to see how other people envisioned a solution to the same problem and learn how to improve your own code.
Simone is an AWESOME professor, is extremely knowledgeable, passionate, available, and adept in answering questions. His grading structure was very fair - you got tests beforehand, but had to pass all of them to get credit. No late penalties, but being late limited your opportunities to get points via participating in codewalks. That said, the implementation of the compilers required is really, really hard and takes a lot of time to write and to debug. Start early, and bring questions to office hours.
At the beginning of the class I had no idea of how complier work and not familiar with C++, At the ending of the class I implemented one complier under great guidance and able to write C++ code with much cooler style. The professor is very helpful to answer your questions. I learned a lot from this course.
This class was the hardest and most time-consuming CS class at NU, but has been the best class I have ever taken. Simone is great at lecturing and is a perfect balance of charismatic while still teaching so much. You learn more in one lecture than all of PL combined
This course pushes you, offering ways to finish assignments in bare bone ways if time does not permit, while allowing you to explore more complex methods whenever you would like along the process of making the compiler

External links:
LinkedIn profile LinkedIn Follow SimoneCampanoni on Twitter Twitter GitHub profile GitHub

Share this page with: