Simone Campanoni

Associate professor
Department of Computer Science at Northwestern University

Simone Campanoni

Computer Science
Northwestern University

ARCANA logo

CS 322: Compiler Construction

Description

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.

Syllabus
Department page

Material

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 2022-2023 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
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

Evaluation

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
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 25.62 5.79 5.57 5.67 5.60 5.65
Total 205


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?"

2022 - 2023

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.
yes. homework make me learn.
Yes. The class is well structured and the professor put in a lot of time and effort to design the course
This class will turn you into an experienced C++ programmer and teach you so many important computer science concepts.
Yes, simone's great!
YES THIS CLASS WAS AMAZING! The teaching style allows you to demonstrate your knowledge and get feedback on your code.
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.
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.
Simone is GOATed with the sauce. Really great lecturer. Be wary though. Most time consuming class EVER.
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.
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.
yea class is a bunch of work. did it tho. you WILL learn.
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.
One of the best courses I have ever had.
The challenge was there for sure, I wanted to learn and be challenged and that's exactly what happened
Figure out visitor patterns before you take this.
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.
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.
A lot of work, but definitely worth the effort.

2021 - 2022

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.
Simone's teaching style of showing by example and motivating stuff during lecture is really superb
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
Yes, the course helped me learn! The professor was very patient and ensured he explained everything without assuming background.
Yes, a huge amount
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
I'm surprised that compilers can be broken down in to many mini compilers and each of them focusing on one topic of compiler.
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.
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!
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.
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.
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.
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.
Yes, a lot

2020 - 2021

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
100%. It explains complier by building a compiler.
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.
Yes, assignments and gamified grading were excellent
Yes. The hands on experience implementing a relatively large project was a huge learning experience.
Yes, the incremental development of the assignments allowed me to learn the individual concepts within the context of the area.
Not only did I learn about basic principles in compiler consturction, I have also learned a great deal in software development and design principles.
This course helped me learn how to take complex compiling processes, and make it in a step by step procedure that I could implement.
Lectures are very solid but leave enough implementations details to the student for it to be interesting.
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.
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
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 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 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
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.
The assignments build upon one another which allows to build up a understanding of the area while gaining expertise on individual subject areas.
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
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.
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. 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.
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.
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.

2019 - 2020

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.
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.
Yes. A great and systematic course.
I learned more in this course than in any other.
It helps not only about compiler, but more on elegant coding styles and design strategies.
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.
This course's content was straightforward and easy to understand. The challenge was in the coding.
This is an awesome course. Arguably the best course in CS.
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.
Yes, the work was extremely open–ended but lots of support was given in the framework.
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.
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.
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.
The design of this course is very helpful to develop basic coding styles. It helps outside of this course as a programmer in general.
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
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.
This class made me a better coder.
Everything in this course is just perfect. Not for the faint of heart though.
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.
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.

2018 - 2019

The professor was certainly on top of his game. He facilitated learning greatly.
Yes, I felt I learned a lot about C++, compilers, and software development.
yes, challenging material, lots of coding, forces you to think about the code
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
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.
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.
Absolutely!
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.
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 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.
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.
great course, teaches you to code
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!
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!
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.
Great course focusing on development of real working compilers.
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.
This class is very hard but it gets a little repetitive after the first few weeks.
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.
Fun course 10/10.
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.
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.
Well–organized, interested in the class and the students
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.
very passionate, available for office hours, well structured course
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.
Letting student build a real compiler of their own instead of teaching too many theories.
Very organized, explained complex topics well.
Engaged and knowledgeable.
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.
He is passionate in teaching and actually teaching the subject well.

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.
Yes. I learned a lot from the professor on how to write clean and beautiful code.
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.
Though I need to cost more than two days per week in this course. This course is fantastic.
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.
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.

2016 - 2017

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.
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.
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
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.

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

Share this page with: