Course Details

Pros: 1. Was honestly really cool writing a compiler (for a toy, example language though) and learning how a basic one actually works 2. Lectures were surprisingly engaging. Subject is dry but the professor does seem like he genuinely likes to teach 3. No big final project (I hate final projects) 4. You get to practice your Java (you don't need to know it ahead of time, it's very easy to pick up the couple Java-isms needed) Cons: 1. Professor can come across as an annoying personality especially if you ask questions (I do think he is nice though in terms of how he grades and structures the class. I'll say he averages out as just average then) 2. Midterm and final were okay but seemed sorta pointless, did not learn much from them 3. Pacing of projects was very off. 2nd by far took the most effort. I think they should have spread it out better. Not sure why you had to go all the way up to level 3, when they could have made you go to level 2 first, and call that its own project. Detailed Review: Pro #1 definitely holds. Used to get very annoyed by compiler errors, now I get less annoyed :). Makes a lot of sense in hindsight, but I never realized a compiler is really just doing a massive string parse of your entire program. So it now makes sense when an error is thrown because it's not in the format it expects. Again, sounds dumb and basic writing it out, but it was cool for it to actually click. Advice for actually completing the projects: takes a bit to wrap your mind around the first project and the second one too. For the very first one, they'll post examples on the forums which help a lot. You'll quickly realize you basically always want a space for your return value, then your input variables right at the top, then do your operations on those by first making copies of them, consuming them as you do your operations. Then once you have your final result, go store it to the space you made for the return value, and then pop everything else off. To make your life a whole lot more easier for project 2, make sure that your push and store operations are only the relative ones, not the absolute position ones, and that all the code you write works so long as your inputs are on top of the stack, doesn't matter how big the stack is. So like make sure your concat will, no matter how big the stack is, so long as there is two strings at the very top, once you entire concat code runs, you will be left with just the concatenated string at the very top, the inputs will be consumed and gone. If want to make your life even more easier, make sure any named labels you do use are unique for each function you write. You'll understand why that's needed when you do project 2. Get used to debugging here too by stepping over each line and command. You will definitely need to do that a lot later on For project 2, I think there a couple ways to do it, as in formatting your code and the overall approach you take. I think the least amount of issues will occur if you are fine with doing the entire compilation in not just one go around (I can't remember if it's this project or the next one, but you will realize that you can use functions before they are declared so you need some way to know whether they exist, which means you need to loop through the program text twice). The hardest thing to figure out is expressions: just remember that it doesn't matter how much spaghetti code you write, and you can definitely take advantage of global variables since you are writing java code, all you have to make sure is you return a correct program that passes all the test cases. It's useful to have a temporary file that you can write example test cases on and try to compile that with your code often. For the documentation they give you, all you really need is the one page that shows you the token type and all the commands you can call on it. It's useful to find the actual Java class code that does this and have it open in a separate page in your IDE and get used to the various functions you can use. Finally, making a recursive function for each grammar/language line that will return a string of compiled code is definitely the best way to structure your compiler. If you can do the above project, you will be completely fine for the rest of the class. You have quite a bit of time to get it done, just be sure to start early and really think about it how to do it, and take it one grammar rule at a time. It's pretty satisfying when you get it all working. Midterm/final were kinda annoying with some tricky questions. Make sure to watch and rewatch the lectures. Midterm was mostly just multiple choice and fill in the blank, but final actually required paragraph answers. Again, if you understand the practice tests given to you (and carefully read the diagrams and/or understand the question being asked) and really understand the concepts being discussed in the lectures, you will be fine.

Pros: 1. Very well organized and administered course 2. Optional problem sets help understand material 3. Professor is really interested and passionate about the material which comes across in the high quality of the lectures Cons: 1. Occasional mistakes in lecture slides 2. Assignments can be a grind 3. Detailed Review: Breakdown of time: (HH:MM) Assignment 0: Setup 0:36 Assignment 1: SaM string library 7:21 Assignment 2: LiveOak 2 40:32 Assignment 3: LiveOak 3 21:41 Final Exam 2:01 Final Review 3:02 Lectures 15:26 Midterm 2:15 Midterm Review 4:48 Problem Set 1 0:57 Problem Set 2 0:40 Problem Set 3 1:00 Problem Set 4 0:49 Problem Set 6 0:46 Problem Set 7 0:27 Problem Set 8 0:11 Problem Set 9 0:25 Total 103:02 Note: I paired this course along with Android Programming. This was an excellent course from start to finish. The professor is clearly very knowledgeable and passionate about the subject and also cares deeply about providing clear, cohesive lectures. This was one of the most well-organized courses I've taken to date. The lecture content is generally pretty interested and is supplemented with optional problem sets to help reinforce concepts. you can submit the optional problem sets if you want, and there is some potential benefit to your final grade if you choose to do so. It is unclear and undefined what that benefit it, so I mostly just reviewed the problem set solutions when they were released. The exams are fair and mostly aligned with the lecture material. It definitely helps to have some prior systems background (like AOS) before taking this course. The assignments are something. The first one is fun and easy and gets you familiar with the SAM instruction set and architecture. The second assignment is a massive undertaking where you build out a compiler for LiveOak0,1&2 language features. The 3rd assignment extends your code from assignment 2 and you build out LiveOak3 language features. The assignments build off of each other which is really cool because you're working in the same code base for the whole semester. It's also scary though because there is no solution released, so if you get stuck on assignment 2, you're not going to have much fun doing assignment 3. The projects are HUGE. You have a lot of time to complete them. DO NOT procrastinate and start them late. Also keep in mind that because they build off of each other, it makes sense to think about keeping your code extensible as you're working on the earlier assignments. The course could be a grind at times, but overall it was really solid.

Pros: 1. Low overall time commitment, by far my lowest total hour count of any course in this program (~120 hours total) 2. Good practice with compiler implementation through assignments 3. Cons: 1. Low time commitment is due to unengaging lectures that are not necarry to watch to do well 2. Programming assignment 2 took just under half of the total hours spent on this class 3. Detailed Review: This course is good to get your feet wet on compiler design and implementation basics. However, advacned topics are brushed over in lectures, and not throughly tested in exams -- so difficult to prioritize really learning the advnaced topics given time constraints of concurrent full-time work. I found the lectures to be unhelpful. The programming assignments themsleves were well-written, and Ed discussion was well-attended to by both the professor and TAs, so lecture were not needed for success (also: unlimited GradeScope submissions). The lectures were not needed for the exams, going over the optional weekly assignments was sufficient, in addition to going through the past years' exams that are provided. Because assignments makeup 60% of the grade, and 90% is the cutoff for an A (at least in Spring2024), it is not terribly important to do well on the exams to do well in the course. I spent roughly 120 hours on this course total, with ~80 being dedicated to programming assignments, ~25 being dedicated to studying for the 2 exams (via going through the optional weekly assignments and old exams), and the balance speeding through the lectures. I did spend about 50 hours on the second assignment, which is essentially writing the core of a compiler, stopping just before object-oriented syntax handling. The first and third assignments (first = simple warmup to the "assembly" used in this course, third = adding object-oriented syntax handling) were both extremely manageable. Even though the second assignment took awhile, course materials are relased in 2 batches (beginning-midterm at start, through final released at end of midterm), so there's plenty of time to get it done. Overall, solid course if you want to try writing a relatively simple compiler. This course would be more meanignful if you take the time to self-study the advanced topics touched on in the lecture. Otherwise, extremely manageable on a constrained schedule (work, life, etc.) -- I'd recommend taking this course in the summer, if it is made available.

Pros: 1. Learn about how compilers work 2. Assignments build off one another 3. TAs were awesome Cons: 1. Despite heavy projects, there are still exams 2. Problem sets (optional) 3. Professor was okay Detailed Review: I think the subject of the course is super interesting and the assignments were practical. The TAs for the course were awesome and went out of their way to explain everything. What I did not like was the optional problem sets as these were used as potential grade boundary decisions. These problem sets were good for studying, but I just did not have much time to give them a 100% of my time. I felt it was difficult to complete these weekly problem sets while trying to write the compiler. The professor was involved in the course, however, he is a pretty straight-forward type of person to say the least. This translates to an environment that is not really optimal for asking questions. There was a response on Ed from the professor where he said something like, "I don't expect questions like this from a graduate course". I get that, but the backgrounds of students can vary dramatically in this program, so I think that type of mentality is unfortunate. If you do take this course, I'd recommend reading Crafting Interpreters and building something yourself prior--and use an AST it will save you so much time!

Pros: 1. Great lectures: clear and easy to follow 2. Projects have good test cases to verify correctness against 3. The course load has been adjusted from previous iterations Cons: 1. Some of the lectures come before they are necessary in terms of the projects 2. Lectures are quite high level theory in contrast to actual implementation of projects or the problem sets 3. Midterm and final were difficult and seem to go beyond what lectures provided Detailed Review: I took the summer version of this, which is only 10 weeks instead of the standard 16. I wonder if the normal semester-long version might be more difficult or have additional topics. Project 1 is straight-forward and fun. Project 2 felt like being thrown in the deep-end of the swimming pool after only having some time wading around in the shallow-end. As others have mentioned, definitely implement an AST for this portion. I find the theory parts of this class boring. It was a drag to get through the lectures even with them being clear and easy to follow. Be careful with Project 3 - the implementation lectures mislead and required clarification on Piazza. If you're wondering how to budget time, this was my breakdown per week: - W0: 6.25 hours [3 hours (lectures); 3.25 hours (PS1)] - W1: 6.5 hours [2.75 hours (lectures); 1 hour (PS1); 1.25 hours (PS2); 1.5 hours (project1)] - W2: 6.25 hours [3.5 hours (project1); 1.5 hours (lectures); 1.25 hours (PS3)] - W3: 16.75 hours [2 hours (lectures); 2.5 hours (PS4); 12.25 hours (project2)] - W4: 11.25 hours (project2) - W5: 7.75 hours [0.5 hours (PS3/PS4); 1.5 hours (OH); 2.75 hours (midterm prep); 3 hours (midterm)] - W6: 6.75 hours [2.25 hours (W6 lectures); 4.5 hours (W8 lectures)] - W7: 0 hours - W8: 2.75 hours [1 hour (lecture); 1.75 hours (project3)] - W9: 18.5 hours [13 hours (project 3); 1.25 hours (PS6); 1 hour (PS7); 3.25 hours (W9 lectures)] - W10: 3 hours [0.75 hours (final prep); 2.25 hours (final)]

Pros: 1. Constructive, engaging projects 2. Mostly well structured, informative lectures 3. Good project/exam grade weighting Cons: 1. Lectures disjoint at times with unexplained logical leaps 2. Not uncommon for professor to be considerably wrong in both lectures & exams 3. IMHO first project had excessive boilerplate Detailed Review: Honestly, I can’t say I enjoyed this course. But at the same time, I know objectively this course isn’t bad & for those like myself that didn’t like it much, a few changes & this course would be excellent. For one, there were too many mistakes & errors in lectures & exams for me to forgive. On the midterm, the professor phrased 1/4 of the questions centered around a prompt which assumed a provably false claim to be true. The topic was also fundamental to the theory of the course. This resulted in several questions which were truly unanswerable. How can that be allowed to happen? At least once per week in the lectures, the professor would say something which made no sense, only to flip-flop the words around later in the lecture to compound the confusion. Sometimes these mistakes resulted in having to rewatch the lectures. With all that said, I am someone who can’t “just go with it”, & I can easily tell if you are someone who is OK with just going with the most obvious choice, you will generally not be as dissatisfied as I was. I also can’t deny I learned a ton about compilers, coming from someone who only had a minor in CS with no background in compilers. The projects were super helpful to understanding, but the first project could be absolutely miserable if you don’t design it well from the start. It is a substantial piece of software, too substantial in my opinion. I had to take off 2 days from work on the week of the deadline & put in probably 40 hours just that week. I think our time would have been better spent if LO-1 were implemented for us & we just expanded to LO-2+ (language levels of the fake language we implemented). I also agree with the other review from this summer, suggesting quizzes instead of exams. You would have to try to get below a B in this course, given the generous grade weighting & unlimited submissions for projects. An A is entirely doable as well, so I can’t beat on this course too much. Final note, the exams were in my opinion frustrating & unfair. He provides the previous semesters exams, so maybe he just felt like throwing in more brain teasers & pointlessly complicated assembly this particular semester compared to last, but beware & probably don’t have super high expectations. A large portion of your grade on the exams is up to how well you interpret his cryptic problems (IMO, a crapshoot, best off just going with your gut & not over-analyzing because you WILL find ambiguity). Multiple choice all/nothing is also an unforgiving format. Luckily, you can average a 75% of the exams & still get an A easily.

Pros: 1. Good and concise lectures 2. Programming assignments follow lectures 3. Exams open-note Cons: 1. Compiler takes a while to build taking less time to study for exams 2. Problem sets don't reflect problems in exams 3. Large codebase (con if you are not used to this) Detailed Review: I really enjoyed building the compiler and seeing how it works and it was fun just implementing the ideas from the course into actual application. I didn't like how the compiler could either take a lot of your time or not since the bandwidth could vary from person to person. This turned out to be a con for me as I personally didn't have enough time to prepare for the exams but since the compiler is worth 60% of the overall grade even getting a 50% average in exams will result in a B in the course. I really think exams should be replaced with weekly quizzes since they are already open-note and will allow students to focus on the current week's topic and reinforce that. Other than that the professor is really good and well-spoken and makes lectures interesting and concise and is able to explain high-level complex topics in a really simple format. I would definitely recommend taking this course as it will give anyone a solid foundation for programming and becoming a better developer. Do keep in mind getting an A takes a little bit more effort but should be manageable if you have the extra time. For the rest of us that have a busy schedule etc. getting a B is not hard, just split the compiler work through the time frame and should be good.

Pros: 1. Very practical material that covers stack and register machines 2. Projects are auto graded and can be submitted at will 3. Material for exams are well defined and graded fairly Cons: 1. New course which wasn't well scheduled, projects were often delayed/skipped 2. New projects which had incomplete/inaccurate/confusing directions at times 3. Projects do a bit too much hand holding, don't leave much room for self-direction Detailed Review: If you don't know assembly or Java, you'll have to spend some extra time on your own getting up to speed. Homework is optional, but it will help with exams if you are new to the material. However, homework submissions are used as an optional curve by the professor. Projects, which account for 3/4 of the grade, are automatically graded and you can submit them multiple times. If you are willing to put in the time, you can almost guarantee a good grade in the course. (And they often will take quite a bit of time) Most of the focus was on LiveOak which is a Java-like stack machine based language. The class unfortunately didn't get to spend much time on the x86 register project due to delays. Overall, I really enjoyed the course. Once it's had a couple semesters to iron out the wrinkles, I think it could be great.

Pros: 1. Assignment is to build a Java-like language's compiler, very cool 2. Covered some useful topics that will help you become a better programmer (GC, memory allocation, x86 assembler, ...) 3. Midterm and Exam are easy Cons: 1. The first assignments are quite time consuming (3 in total) 2. Assignments are all autograded, but the test cases are full of mistakes and got fixed few days before the deadline 3. Not all topics have problem sets to help you consolidate the learning Detailed Review: Be careful if you are not fluent in Java and its build tools (maven / gradle), the first assignment may take you more than 60+ hours as reported by other students in piazza. And I , as a Java developer with 2 YOE, spent ~24 hours for the first assignment. But the second and third one are much easier, only took me around 8 hours each. The content of the course are very useful, I got a brand new understanding about programming language like C/C++ and Java, definitely recommended.

Pros: 1. Fairly thorough coverage of the subject matter by a Prof that clearly knows and loves his subject 2. Pretty well structured course with exams that match the material very well 3. Most of the grade comes from projects that have 100% given test cases - if your code passes the test cases then you know your grade already - if it doesn't you can resubmit until it does so it's all on you Cons: 1. This was the course's first run so there were some hiccups - the Prof bent over backwards with accommodations and so I don't think this was a huge issue, but it was irritating - that's what you get for being the first to take new course ;-). I doubt this will be an issue for the next class though (you're welcome) 2. Does have a dependency on Java (which I don't think it really needs) - no issue if you know Java and it's not hard to learn 'enough' Java for the Labs so not a big deal IMHO 3. Detailed Review: This is a well structured course that looks and the theory and implementation of modern programming languages. The main project has you building a compiler for a made up language, that will evolve throughout the course. You will compile this language initially to another 'fake' language (SaM) which is a stack based language design for teaching purposed, and then later directly to x86. Prof gives you the key ideas in the lectures and then you are supposed to figure out how to apply them in real world code - you can get full marks by just doing what he suggests, but the more of the 'fancy stuff' you implement in your own code, the more you will learn - it's up to you whether you are chasing an easy grade or packing in the learning. There is a straight theory component and that's a bit of head scratching, but the exam was very fair and not a heavy part of the final exam so it was entirely possible to get a 'A' even if you were better at coding than the theory. The grades are straight letter grades (i.e. A, B, C - not +/-) which means if you would have got an A- you'll still end up with an A, but if you might have scraped B+, that's still a B - a blade that cuts two ways. Overall, a strong recommendation for the course - the 'hiccups' that were present in the first release have been mostly ironed out - I suspect Prof will tweak a few things for the next run, but if you want to understand how compilers work and get a good insight on how you might use this to write better code - this is a great course and a lot of fun. There's a fair amount of work in the first few weeks (part of what I think the Prof may well tweak) but it gets much easier around half way through.

Pros: 1. Professor is very knowledgeable and passionate on the subject. He spends time teaching the concepts. The delivery is not at all hurried so you can understand concepts 2. Labs (once you know how to do) are very good and directly relate to concepts being taught 3. Exams questions were pretty good and makes you apply all the knowledge Cons: 1. MIA TAs - Piazza was completely driven by Students. TAs would rarely answer a question and if they do , it will be weeks after 2. Assignments were poorly driven- test cases were more often than not wrong. Students fixed and provided correct test cases, TAs were completely clueless 3. Very excessive workload. At the end it felt as if everything was crammed up. This course definitely has enough material to be driven as two separate courses. Even though the topic is interesting, too much content made it very hard to learn Detailed Review:

Pros: 1. Subject matter is interesting, and the lectures are really good and very in depth. 2. The projects are significant problems and you will learn a lot from doing them and come out a better engineer at the end. 3. Cons: 1. Fall 2021 project scopes were maximally large for a single semester. This would have been okay, but... 2. Fall 2021 project autograders were not ready ahead of time and were not tested before being opened to students. This left students wasting a lot of time trying to figure out if the problem was the grader or their own code. 3. Fall 2021 project specifications had some errors in them. Detailed Review: If the projects had been more fully prepared by the course staff, this course would have been one of my absolute favorites along with Parallel Systems and Natural Language Processing. I expect that future semesters will be smoother as a result of our suffering, so, if you're reading this, you're welcome. The planned scope of the course projects was to implement a compiler for a single language with two target architectures. The concept was good, although the amount of work was very large (comparable to or even more than PS). But the project specifications were not proofread carefully enough, and the autograders weren't tested at all before being released. This meant that we had a project schedule that had no room for wasted time, but we were forced to waste a lot of time with back-and-forth on Piazza working out these issues. This caused a lot of unnecessary stress. To the professor's credit, he did address the issues and ended up reducing the scope of the last projects allowing people to catch up. I expect those issues to be mostly resolved in future semesters, so I would definitely recommend the course in the future. Building a compiler in this depth is a fantastic learning experience in engineering a large, complex piece of software. The lectures are great and deeply informative (to the point of being longer than any other courses's lectures, but worth it).