CS 323: Code Analysis and Transformation

This class is definitely as hard as people say it is, but doable. The course covers how industrial grade compilers optimize and transform the code that you write. You get a lot of exposure to the technical tools used to do optimization (clang, LLVM, c++) as well as even more exposure to the conceptual/theoretical ideas behind different kinds of optimization techniques. For hw, you are essentially building a program to optimize a library of c++ functions that Simone has created. You start off with very strong assumptions and simplifications, but as you progress through the quarter those assumptions relax and you are asked to add more features. There is a new assignment every week, and your solutions build off of your solutions to the previous assignment. The homeworks get progressively more difficult and peak at hw 6, before they get easier again. I'd say that even the hw is very challenging, it is challenging from a conceptual standpoint rather than a technical one. If you want to take this course you should be very aware that this class requires a very large time commitment, and that many students drop because of the workload. You should also be aware that it is very easy to fall behind since each hw is dependent on the previous, and there is very limited support. There is only one PM and TA, so there are only a few OH per week, response times on Piazza on long, and it will take some time for Simone to give feedback on your assignments. Aside from that , if you are able to make the commitment, I'd say taking a class with Simone is a very rewarding experience. Simone has really perfected how he teaches this course, and he somehow has a way of breaking down and explaining the most conceptually difficult topics into understandable chunks. Even though his class will work you like a dog, Simone is extremely kind and sincerely cares about making sure students understand the course content.

This course was extremely challenging and time consuming. Be prepared to spend more than 20 hours a week on assignments if you're not a genius. On the flip side, you will learn a ton about the conceptual aspects of code optimization and the middle–end of compilers. Also, there are no exams; all of the grading is based on homework and extra credit opportunities.

Another excellent class by Simone. Its a good idea to take CC before this, and while CAT is not an easy class, I found it to be less work than CC. Simone is very passionate about teaching, and he wants to make sure you learn the material. There's no exams, just weekly programming assignments. HIGHLY recommend you take this if you are interested about compilers.

This is one of the best courses that I've ever taken. Prof. Simone is an amazing instructor and he pays a lot of attentions to details to improve students' experience from the course. The homeworks are quite challenging, and it feels very satisfying and rewarding when my solution passes all the tests and even further optimizes the program in some cases.

I learned a ton about the inner workings of compilers, and it really helped me figure out what goes on behind the scenes and what I need to do as a programmer to help the compiler do the best job it can on my code.

It turned out to be extremely difficult and time consuming, and I got quite behind on the work. But nevertheless, I really enjoyed all the topics we learned, and it was interesting from beginning to end.

This class is possibly the best one I've taken in the CS department. Expect to spend a lot of time, but not one second of that time feels wasted.

It did help me learn. It introduced some concepts that I think are good to know for anyone who study computer science.

I have always been interested in how compiler optimizations work. This class has been a good start!

I learned a lot from the course. The coursework is very well–designed and logical to follow.

The course introduced a lot of interesting concepts but the homework load was just too much.

Yes. The lectures are very interesting and the assignments are engaging.

– Challenging class, but very rewarding. – Simone is the best lecturer I have ever had. He is always super prepared and knows exactly what he'll talk about and when, but is also able to flow with questions and tie stuff together for you – In my experience, Professor Campanoni's difficulty distribution for the homework is a bit inaccurate. You may find that what he labels as the most difficult is actually rather easy (depending on your design choices/decisions). – Please: Listen to Simone and think before you start coding. – The grades are based off of 10 homeworks. – No final exam. – An INSANE amount of extra credit opportunities (but probably differs from year to year).

This is the most demanding course I have ever taken. You will spend more than 20+, if not 30+, hours on assignments starting from the 5th week. Although challenging and intimidating, it is also rewarding after you survive the course and discover that you can understand all the secrete in the middle–end of the modern compilers. You won't regret spending so much time on this course.

Yes! Simone's lectures are unbelievably well done. I cannot stress how impressive his lectures are. Simone is super knowledgeable and able to help with answering questions but also pushes students to think for themselves. But yeah, overall, preparedness is the word of the day when it comes to his teaching.

The course is focused on code optimization and the workload is extremely heavy. But Simone provided many extra credits to help you survive. If you just want to earn a grade, try another; but if you are interested in compiler and code analysis, this course deserves.

Yes! Simone is knowledgeable and passionate about compilers. I can learn and discuss everything I want about the middle–end of the compiler in class. The assignments are well–designed, and I found them valuable to support my learning.

The coding part is quite challenging and could help us learn how to use LLVM to do some important code transformations. Also, Simone introduced many useful concepts about code analysis, which would help us a lot in future researches.

Yes, the course taught the problems and the concepts for solving them, and new undiscussed problems will be the homework assignments that allow us to utilize the knowledge learned in the class to design algorithms to solve them.

Yes! The class structure of project–based learning was very helpful in forcing me to think through the topics learned in class.

This course is extremely valuable and interesting – but it is challenging and time–consuming. I took this class before CS322 so this was my first exposure to compilers. This course focuses only on the middle–end with CAT but it's really cool to delve into this world of compilers. The 9 homeworks build on each other and become increasingly complex, taking 20+ hours a week, especially if you fall behind. Simone recommends taking time to think through the assignment before implementing anything and that is the most painful part – to discover a bug in your algorithm and have to start over completely. Simone originally didn't intend to make lecture recordings but he started doing it 2 weeks in after some people weren't able to attend. I think those were a lifesaver because his lectures can go fast and it may be difficult to understand him. Other pros and cons: The grading system is quite forgiving – basically, you can submit assignments super late, and there is extra credit at the end of the quarter which can raise your grade 10% even if you struggled all the way through. Also, Simone was generous about class–wide extensions. The assignments are designed s.t. you have to independently develop (with a partner) and implement solutions, so the OH aren't much help – anyways there was only 1 PM so there was a total of only 2 OH/week. Simone was very nice in his office hours though – he is a great professor really cares that you learn. Also, the responses on Piazza were quite slow and sometimes Simone would disappear without posting or releasing some assignment he promised to do.

This is a pretty tough class, but you will learn a ton. The weekly assignments start out not too bad (maybe 4–7 hours to complete) but then become extremely difficult and start taking in the ballpark of 10–20 hours to complete. Simone is a great professor and was committed to helping everyone with office hours and extra lecture time, but regardless it was pretty difficult. It's also partner–based, so pick someone ahead of time that you can rely on and will put in the work. On the grading side, it was nice that the class is all points–based – if you have a point total that you are happy with at any point, you don't need to do any additional work. There were 10 total assignments but 110 possible homework points, along with lots of extra credit opportunities in class. Overall, it was one of the most challenging CS classes, but if you're able to buckle down and grind the assignments you will do well.

This course is very challenging. Only take it if you are super intelligent or highly interested in Compilers. There are ten assignments in this class, and each week an assignment is due, and every one is based on the previous one, so you cannot give up a single one in the middle. The first three to four homework is not too hard, but the rest of them each took me 20 or even 30 hours per week. You can tell the professor is an excellent instructor who excels in compilers, and he is trying to keep improving this course by listening to students' feedback. But I probably wouldn't have chosen this course if I had a second chance, simply because it takes way too many hours.

This class is a ton of work, but Simone is great and you’ll definitely learn a lot if you’re willing to put in the time. Assignments are all cumulative which adds a fair bit of stress, and because they are so open–ended as to how you implement your solution, you can quickly have very messy code that’s hard to debug. LLVM is a pretty niche field so google won’t help you as much as it would with a class in python, and lectures are more about concepts than implementation. The online LLVM api is pretty barebones and hard to read (seriously, google doxygen LLVM api and check it out), so use piazza a ton.

This class is very challenging and requires many hours of debugging per week. Between like 8 hours for the easiest assignment, to over 20 hours for the hardest assignment. The material is fairly interesting. Once you get behind, it is so hard to catch up. There are some opportunities for extra credit, though. Also, do not rely on the professor to give feedback/grades in a decent timeframe. He is very nice, although not reliable when he says he will do something by some date/time. Grading is also very inconsistent between different assignments (he said he doesn't really have a grading schema).

This course is really, really hard. First few homeworks are straightforward, but then the course really picks up and it becomes pretty exceptionally difficult. The lectures are all high–level theory, so we were pretty lost when trying to actually do the homework that involves actual application of theoretical concepts. We spent at least 10–15 hours a week on the later assignments, and that was just to try to pass. The good thing is that there are no tests, and the late policy is pretty forgiving so that you can still get a good number of points even if you turn in HW a week late.

Simone is a very empathic professor and has a very effective teaching style, but he will also work you like a dog. This is possibly the most time intensive class that I have ever taken. At the same time, I have probably learnt way more in this class than in most of my classes. Compliers and learning how they optimize code is also an interesting and intellectually simulating topic. If you want to do a deep dive of compliers, this class will help you do so, and Simone is able to support students that go above and beyond. The class also has no tests, which is pog.

The content of this course is not what I expected to be but still interesting. However, the weekly assignments style which every assignments depends on previous ones makes no room for you to make mistakes. In order to get full credit each week you need to invest tons of time in this course. Overall, it's a quite challenging course.

The homeworks ensure that you will learn a lot. They are very difficult, and the test cases do cover many edge cases, so you can't just half–ass them. The lectures are also more interesting than the average engineering lecture, and Simone has a good incentive system to make people interact in class.

This course is definitely challenging but still very interesting. Simone is a very thoughtful professor who listens to his students. He also expects a lot out of his students, so be prepared to spend a long time just thinking about what a given homework assignment is even asking for.

The course is hard, but you also learned a lot while challenged by the assignments and lectures. I would say compiler middle end is a CS system guy's must for long–term development. Professors TA s and partners all really help during this process. Success is not a solo endeavor.

Yes, a lot. Simone explains things well. He never makes you feel like you are stupid. Helpful on discussion boards, and is not afraid to go into detail when it would help understanding. He also does not repeatedly cover topics from prereqs, which is nice.

Yes, this is one of those classes where you learn by struggling. You really had to make sure you understand the class content, and you had to be really creative and independent in how you applied that knowledge to completing the HW assignments.

Yes, I learned a ton because the assignments were so challenging. The lectures were sometimes helpful for a starting point, but much of the synthesis was done on my own while working through the homework assignments.

Simone is a fantastic professor who's interested in continuously improving his classes. His classes, while somewhat challenging, are 100% worth it. Having a partner in this class is recommended. Don't fall behind.

Yes. Through coding assignments especially, my partner and I really had to think through what we learned in class ourselves in a detailed manner.

Yes! Simone is a very clear lecturer. He also clearly cares about his students and puts in a lot of time to answer questions.

Course definitely helped me learn simply by virtue of how difficult it was.

Yes, the material was extremely interesting and helpful.

Yes.

This class is excellent. The homeworks are the core of the class and very interesting to figure out. Some lectures go a little fast, so it's possibly helpful to rewatch. The homeworks do take a lot of time––this was the most time consuming class I've taken at NU. While I enjoyed the homeworks a lot, I didn't really get the sense that they were teaching me a whole lot––a lot of times I conceptually understood what I was supposed to do, implemented it with a little hassle, but then didn't pass all the tests cases, and spent most of my time trying to get the last few test cases to pass. It was fun for me, but at times a little draining. My advice to students in the class would be not to be biased against ad–hoc solutions. Implementing a few (correct) ad–hoc transformations helps a lot. The professor and the TAs were very helpful. I would recommend taking this class with a friend, or to be ok with doing all the work yourself. A A bad partner will really cause you to suffer. Not just because the workload is large, but because it's really painful to debug everything with nobody to talk to. I spent a lot of time telling my brother about all the bugs in my code even though he doesn't know anything about compilers, and it was pretty helpful. All that being said, it was by far the best course I've taken here, and I'd do it again (with a friend) in a heartbeat.

Excellent course, easily the best I've taken at Northwestern. Simone is an amazing instructor and this course is about the same kind of stuff he does research in which makes for a great intellectual environment. Be warned that it is a decently heavy class. There is one HW every week and they each build on the last, so DO NOT fall behind. Thankfully Simone is generous with extra points (I think the maximum possible just from the assignments + 1 extra credit assignment is 130 points) and he makes up for mistakes he makes in the assignment tests or other issues with extra points. Easy to do well in IF you do the work. There is a generous resubmission policy as well. If you have any interest in compiler optimizations and are willing to work a little for the knowledge you'll have a great time.

The assignments in the second half of the quarter are extremely challenging, I had to spend more than 20 hours each week on this course(which is expected by the instructor). The tests for the assignments only detect limited bugs and could not really guide you to do the assignment right. In addition, each assignment depends on the previous ones, if you fail to get one right, it would be hard for all your following assignments to achieve the expected optimization level.

This class was one of the most difficult CS classes I've taken, but Prof. Campanoni is a great professor, and he truly cares that his students learn. I highly recommend this course.

Still need to iron out the bugs but I think you are aware of what can be improved based on our last class. After fixing these things I think it will be an excellent course.

Yes, the course did help me learn. It covered material that I had not seen before in a fast–paced format. Additionally, Simone and the TAs were very helpful.

Overall I thought this was an interesting course, very relevant to my interest, and taught by an instructor who is an excellent teacher.

Lowkey super hard and time consuming. Would definitely recommend having a solid background working with C/C++.

Compiler topics are nothing if there's no hands–on challenge. This course has rich hands–on experience

It was relatively helpful because there was a lectures and related homeworks to it

The concepts in this class are totally doable but the homeworks are very hard. The "hw N+1 requires hw N" philosophy really made it tough to keep up. If you really feel like this is necessary then you should make the late policy more lenient. When you are late of a homework all of the sudden you are losing points on that assignment and potentially also the next assignment unless you are able to finish both in the time it is supposed to take one. The compounding effect here was tough for me. See Vincent's 321: Hws are actually doable, don't depend on each other, and the late policy is much easier on students. Despite this the class has a very similar format to this one. Other things: C++ needs to be in the course description, at the top. I think there should be more guidance for the hw's in terms of what our approach should be because I really would never have come up with most of the answers to these homeworks without Piazza. Also, there needs to be more faculty engagement on piazza. None of my 4 piazza questions were answered by an instructor and that is really uncool, espescially in this distributed format.

This course is immensely challenging, but you really do learn a lot. The first couple assignments are pretty trivial, but they quickly scale up in difficult so that by week 4 you're pretty deep in. This class is kinda off the beaten path of most CS majors and it certainly isn't necessary knowledge to be successful in the field. That being said, I feel like knowing what a compiler can and cannot optimize away has made me more conscious of the code I write. The class becomes immensely difficult around week 7–8 though and I cannot imagine taking it without P/NP. Take this class if you want a challenge and you have a light course load – otherwise I would steer clear.

This course was very interesting and helped me learn how code is optimized. This class is difficult for those that aren't familiar with C and C++ and don't have much experience with systems programming. LLVM documentation is very hard to navigate, with many functions not having descriptions. It was a good design for the class to have the homeworks build up on each other, but at times it was hard to keep up, especially if you fell behind.

Great class, great professor. A bit more manageable than 322, but that is a high bar to compare to, so this class is still a lot of work. You will learn less software engineering skills in this class compared to 322, and more thinking/theoretical skills, although software engineering is still valued more than a lot of classes considering your assignments build off of each other week by week.

I enjoyed this course, but found it much more difficult than other CS courses. Professor Campanoni is great, and explains things well. The homework assignments were very difficult, and I felt less supported on them than I would have expected (though this likely has to do with online format).

I felt that Simone was a really strong professor, but the lack of documentation for LLVM made the homeworks extremely hard to complete. My dislike of the homeworks made me extremely unmotivated in class

Learned a lot in this class, exposed a lot of the technology that is under the hood when programming and demystified a small part of what goes on.

This class was hard. I only barely passed. You need to know C++, and you need to be prepared to spend a lot of time on the homeworks.

Using LLVM to build code analyses and transformations; great introduction to concepts and implementation of middle end.

The course definitely helped me learn. I honestly found it very challenging, but overall I felt like I learned a lot.

Overall, a really great course. Pretty difficult, but Simone taught it very well and it was really interesting.

Yes, the course was insightful into how the middle–end of compilers work to optimize code and change code.

Overall fantastic, I felt a lot of material in was covered a very clear and concise way.

Absolutely, particularly being able to apply the material through the homework.

Yes I learned a lot about the intermediate layer of compilers in this course.

Yes focusing on using real a compiler framework like LLVM is great.

Yes, it was really cool to see how code transformation works.

Enjoyed learning all the new concepts and implementing them.

Yes by building on previous concepts/homeworks

Alot. Completely new concepts for me.

Interesting concepts, hrad class

Yes, prof was great

This course is about using LLVM compiler infrastructure to write our own code transformation pass within an industrial compiler "clang" for a simple specialized language "CAT". The course is full of fun and challenges. You will learn lots of concepts in code analysis, but also you probably cannot gain full points for the homework if you don't take it seriously. Simone is a really great professor at Northwestern and he is extremely passionate about what he is doing in compilers. I'd recommend also take his course CS322 compiler construction for you to gain a whole picture about what an important role compiler itself and code analysis plays in the whole computer system.

I was very excited going into this course, but I feel like I didn't get as much out of it as expected. The lectures didn't have a clear flow and often jumped around. While the homeworks were very helpful for the topics they did cover, I felt like a lot of things in lecture weren't reinforced. Overall, however, Simone works very hard to improve the class as much as possible for students and takes feedback. I would recommend this class if you are looking to get a taste of the field and be mentally challenged, but the topic isn't for everyone.

This course is extremely time–consuming, but wow does it build character. The professor is a great guy who knows the material well and is willing to help, and the examples he gives on the canvas are quite helpful. However, he is intentionally vague about applying concepts on the slides to the homework, and as a result it can be very easy to get stuck and fall behind. The homeworks build on each other, so if you are late on one, the problems will stack up. Luckily he is aware of this, as the late policy is generous to make up for it.

This class started out great, but by the time reading week rolled around, the TA stopped answering public, general questions on piazza, the assignments got very difficult, and I lost the motivation to continue trying very hard, especially since the professor watched Piazza, but didn't offer any answers himself. Up until week 8 or 9, the concepts were interesting and the homework assignments were fair, though.

The pace of the class was really fast, and after week 5 the assignments stopped making sense. The slides are really unhelpful without the narration of lectures over them, so because it was difficult to keep up in lectures, it was a lot harder to catch up with the slides outside of class. The office hour for the TA was usually at an unhelpful time with regard to the assignment deadline.

This is a HARD class but so worthwhile. I learned more in this class than any other at NU so far. Simone is a great lecturer but do not expect any help on homework assignments. Make sure you have a good partner for this class because that will absolutely make or break you. absolutely take this class but make sure you have a lighter schedule and a good partner

Hard course. Learn about optimization–layer of the compiler, which is super interesting. Every week you build on your own code. Professor and TA are not very accessible outside of class, which makes the last few weeks really hard b/c everyone's having bugs by now but there is not enough help.

Quite possibly the best class I have taken at Northwestern. Simone is a fantastic teacher and this topic directly relates to this research –– always a winning combination. The class gets a bit heavy in weeks 6–8, but it's very fairly paced and gets better every year.

Cool and interesting course and Simone is great! First few homeworks are trivial, next few are ok, then they get challenging, and then they get really difficult so make sure you understand concepts from the beginning but overall I had a good time and recommend it.

This course is pretty challenging. The first few homeworks are easy but the last few take a lot more time. The TA office hours were scheduled at a terrible time, usually right before an assignment is due or after it is due, which makes getting help pretty hard.

The professor was helpful in teaching the concepts, but was oftentimes intentionally vague on teaching the application. Sometimes I felt I wasn't learning what I needed to despite attending lecture and office hours every week.

Class starts out very easy, but scales quickly into a very difficult course. Not hard at all to get a B, but getting an A will take a significant amount of work. Simone is very good a explaining concepts during lectures.

The TA is a little unapproachable. Some of the topics I felt were really tricky to understand, so despite spending a lot of time beforehand, I needed a lot of guidance, which was difficult to get from the TA.

Yes. I've gained knowledge in an industrial–based compiler and make my own correct, stable and effective pass. A good start for me to both work and do research in the field of compiler.

course is really hard, the code you write is cumulative so if you don't write clean code and just try to pass the hws you'll only hurt yourself later in teh quarter.

Everything prior to week 5 is very doable, after that it's a different story... You learn a lot though and Simone is amazing.

Yes, but it was moreso through difficulties realizing the assignments rather than with understanding the course material.

This class had some pretty difficult homework assignments that take up a lot of time but you gain a lot of knowledge.

The process of learning in this class was identical to how I learn, so it was very helpful.

The course helped me learn more about code optimization and how it works internally.

Some of the assignments can be challenging, but Simone is really good.

One of the best, most interesting courses I've ever taken.

This course was cool but definitely time consuming.

Yes it helped learn a lot about compilers.

The projects were well paced out.

yes learned so much from doing

yes, relevant projects

Amazing class. Simone is a great lecturer, and one of the most open˺vailable professors I've ever encountered in terms of help outside of lecture time (or even outside of scheduled office hours). His intense passion and deep knowledge for the topic really come through in lecture, and while the projects are really tough I also found them really fun and the way grading works gives you a lot of flexibility in terms of how you want to work. A very hard class, but super rewarding and interesting.

This was one of my favorite Northwestern courses. I significantly improved my understanding of the theory behind compiler optimizations, the LLVM API, the C˼++ memory model. I also improved my C++ programming ability significantly. It was often difficult to tie concepts from lectures to the homework assignments, because many lecture concepts were beyond the scope of assignments.

I love writing solutions to the problem˺ssignments to this class, and reading the examples/solution code. Those examples and solutions are well designed and well-organized. The content of the course is also organized very well in terms of difficulty.

This compilers course forced me to tailor algorithmic concepts to handmade and original applications the professor designed in such a way that implementation of such large scoped concepts was feasible each and every week.

This course struck the perfect balance between breadth and depth of scope. The pace was nearly perfect. Motivation came from plenty of extra credit (all very hard and satisfying to earn).

Good class, Simone is a great lecturer. The homeworks are hard, especially the last 3, and it takes some time to wrap your head around coding for LLVM but Simone is very helpful.

Yes, the course helps me learn alot only to write a good lean code, but also to critically think about the best approach to solve the problem.

This course taught me about the complexities of CAT and how simple and difficult it can be.

Great course that can make you a better programmer in everything you code.

Absolutely. A great, in depth study into compiler optimization

Yes, now I can understand LLVM.

Yes. Because the teacher is good at giving heuristics and tips for us and also he is able to design the homework of moderate difficulty.

Yes. Having never taken a compilers class, this was a crash course in mid-compiling and optimization.

Yes. The course provides in-depth analysis and breadth introduction to the subject.