Embedded Systems Optimization

Most important note: Never take ESO. If your goal is to learn:

1. Computer Architecture → Take HPCA (High-Performance Computer Architecture)
2. Compiler Design → Take Compilers

-- Other notes:

Project 2 should be removed as it does not contribute much to learning. Thus, the course should be structured with five homework assignments (through changing project 1 as an independent homework), using Python instead of C++ to reduce the time spent on each. To mitigate the uncertainty surrounding the final exam's difficulty and preparation, the inclusion of two midterm exams is recommended. One midterm exam after P1 is covered. Another midterm exam after P2 is covered. And make final to cover only P3-P4 and not cumulative. So, the resulting assessment structure would be five homework assignments, two midterm exams, and one final exam.

What is more, the lowest homework grade should be dropped because this provides a buffer against unforeseen circumstances that may temporarily impact a student’s performance. Dropping the lowest homework grade promotes continuous engagement with the coursework and encourages students to focus on long-term improvement without the disproportionate penalty of a single underperformance.

It would be even better if the lowest midterm exam score is dropped if it is also lower than the final exam. This adaptive policy gives students a chance to recover from early missteps and rewards genuine progress and mastery by the end of the course. It recognizes the non-linear nature of learning and reduces discouragement from early struggles.

All of the course content is outdated by a decade. Lectures are just bad.

Professor is completely disengaged. Only showed up to one or two office hours for 10 minutes.

You learn almost entirely about compiler optimization techniques that are outdated. Very minimal embedded computing content.

The only practical things I learned in this course were computer architecture based.

The head TA Darrell is the only good thing about the course.

There are much better courses in the OMS curriculum that give you real world skills. Stay away from this one.

As others have noted, this class is more focused on compiler optimizations for embedded systems. I was not brave enough to take the compilers course and opted to take this instead. I found the class to be challenging but interesting. One of the reasons I took the course was to get some more familiarity of graph algorithms and I was not disappointed. It was nice to see how graphs are used for various compiler optimizations.

Projects:

The class has two projects, one of which involves writing a VLIW scheduler in C++, and the other involves running performance tuning experiements on a raspberry pi. The first project took me around 40 hours or so spread out over several weeks, whereas the second project took about half that time. I enjoyed the first project quite a bit and it was one of the highlights of the course for me. I was not as engaged in the second project and at times it felt like a chore, but I did learn more about working with my raspberry pi which was nice.

Homeworks

The homeworks vary pretty greatly in difficulty. I ended up spending a lot of time on homework 1 because I was really paying attention to the detail of determing the schedule. Homework 2 took me a couple of hours. Homework 3 was pretty difficult and ended up being my lowest mark in the course. Homework 4 isn't too bad, but I ended up missing some small details that cost me some points that I wasn't expecting.

Exam

The exam was pretty stressful since it was the only exam in the course and constituted 33% of the grade. The homeworks do a pretty good job of making sure you are ready for the exam, but be sure to review all the lectures as there were some topics not in the homeworks that ended up in the exam.

Teaching Staff

The Instructor and TAs for the course were great. There was a weekly office hour that I was never able to make, but I think it is pretty cool when the professor is a part of them. The TAs were dedicated and were dilligent in answering questions in piazza. You could tell that they wanted the students to succeed.

Overall, a pretty interesting course that covers compiler optimizations. The summer schedule is tight, but not bad enough that I wouldn't recommend taking it in the summer.

An update from Fall 2021 - the course structure and content mostly remained the same as Spring 2021 reviews. I paired this with CN, and it was definitely hard to deal with both, but manageable if you're willing to sacrifice free time. That being said, it was definitely a satisfying course with loads of learnings at the end. Like other less explored OMSCS courses, this course also suffers from the mildly unclear project/homework instructions perspective - but it isn't a major issue since the TAs are always on the lookout to clear any questions on Piazza. The only complaint I have is the distribution of the weights with the final exam being a major chunk (33%) of the final grade. With the final project also making up 17%, you'll be left unsure on which grade you will land on even after finishing the exam - and I personally think the projects should be weighted more.

Mixed feelings about the course, mostly positive. Like most less commonly taken courses in the program, it suffers from a lot of underspecification and ambiguous language on the coursework. The TAs and the prof will help you out but it really shouldn't be necessary after all these years to have people asking the same questions over and over on Piazza because they haven't sharpened the wording on the assignments.

Project 1 and some of the homeworks were very cool and did a great job of building a better understanding of the material. The course is heavier on the compiler-y side of things rather than the embedded side, but you get some decent exposure early on so it is a good choice if you like both subjects. Project 2 honestly just felt like busywork so I'd prefer it if they upgraded Homework 3 to be Project 2 or made a more interesting Project 2.

The final kind of felt cheap because you can lose huge points on questions that build on themselves. For example, earlier in the course (and even for another course before that) I wrote a working program that answers a question on the final, but because I made slight errors working it out manually on the final closed-notes I lost like 15%.

A lot of the multiple choice questions on the final are illogically constructed from a question making standpoint. For example, why would you make a question whose answer choices are True, False, or ? Just make it a true/false question or a "check all that apply" question, not both.

TL;DR the content is good but be ready to take a gut punch on at least one of the homeworks and possibly the final unless you really, really rote memorize and scour the readings.

Students had to do a lot of the guess work; what they want, fixing a lot of issues with either the "grammar" and language of the questions, or fighting the autograder.

Most if not all foundational and theoretical questions was either never answered, answered wrong, or ignored, or my favorite, a great TA start saying "I haven't looked into that..." and shares a wiki page as if I don't know how to google around.

Beside Tyson, the head TA who have been on this course for 2 years, who spent majority of his time figuring out the Autograder and other course logistics, we had no other person of acknowledge, including the Prof. (beside the office hour) to answer our questions. Tyson is truly a nice and great guy, the problem is that we were the first to be used on this new autograder, which is going to be great for the student coming after us, but left us with other two TAs who are either absent or know almost nothing of importance.

(I mean, on time, a TA asked what OS stands for!!)

To improve this course, bring on TAs who are knowledgeable, not showing up the night of the exam (when there is already piazza silence period) to answer questions. If not, the Prof. have to show up on piazza every now and then and answer questions. 60% of the material is based on the Prof. papers, no one will know it as much as him.

The homework overall are not bad -- there are some "language" issues as in how it is described. For example, Some TAs didn't know the difference between Instruction and Operation until Tyson had to make a post. And this is an extremely important distinction when we talk about VLIW.

The summary:

The course is amazing, most students who join this course love this low level details. The lectures are long, but mostly organized and well done -- though they could benefit from an update. The homework, Head TA did great job working on automating the grading, although we suffered but it will certainly elevate the course for next students. TAs are mostly don't know more than those students -- sometimes the student knew a whole lot more.

Project 1 is great, just another problem with wordings, and Project 2 is obsolete and needs to be either completely removed and replaced by homework 3 (homework 3 is harder than project 1) or a new project is even better.

The course is a complete to the compiler's course by the same professor, if you take one, I recommend don't take the other.

This was my first course, and my first actual engineering course. My formal education background is in social science, but I have been programming since 4th grade. I am currently a full-time Senior Software Engineer.

I loved this course. It was challenging, but most of that challenge came from my lack of graph algorithm experience. Graphs are EVERYWHERE here. Be sure to understand how to traverse, explore, and build graphs in C++ and Python.. Just about every optimization was a graph of some sort. With a good grasp on graphs and a decent background in Undergraduate Computer Architecture, you should be well prepared for this class. Basically if you can write some basic assembly (even theoretically), do a breadth or depth first search, and are prepared to see these things collide -- you're good to go.

Professor and TAs The professor was at every office hours and did a great job answering questions. He really is an expert in the field and a pretty good communicator. But, I never saw him on Piazza. The only communication with him you'll get is in the office hours. If you have a question for him, you can mention it in Piazza and the TAs will bring it up during office hours. The office hours are also recorded for later use.

The TAs worked really hard and were timely in their responses. They were all active on Piazza. It was my first class, so I have no comparison, but I have no complaints about the TAs.

Instruction and Homework The videos were decent, though there are some errors in the quizzes. Be sure to check out the Errata repository on github for the correct quiz answers. Also, not all the material is really covered in the lectures. Especially the papers are important to read. The lecture may mention an algorithm, but the actual algorithm itself is in the paper. Read the papers.

Beyond the course videos, there is only Piazza and a weekly Office Hours.

The Homeworks/Labs are all over the place. Some coding, some reports, and some "work through the algorithm" where you can do it manually or coding. For the most part, I spent about 10 hours on each homework -- EXCEPT for HW3. It involves a lot of coding (in python) and was challenging. This one homework was by far the biggest time commitment I had. Even more than the projects. There are 4 homeworks total.

The two projects are really interesting. One is all coding (in C++), building a very small part of an embedded compiler from scratch. The other is more like a research project -- profiling some code, making modifications, and justifying your results. I enjoyed both and they both seemed to be generously graded.

The coding seemed evenly split between C/C++ and Python. Basic C/C++ is all that's needed. I'm definitely not a C++ wizard and I got a 100 on all the C++ pieces.

Exam The final exam is a full third of your grade, and this is what caught me. Not that it was unfair -- there were no trick questions or surprises. It was just difficult and time consuming. Be sure to actually work out the various algorithms. Be sure to know the concepts. Honorlock worked great (for me). I felt like the course prepared me for the exam, even if I didn't prepare myself as well as I should have.

Overall I really enjoyed this class and it was a great first class. It doesn't require so much background knowledge and is a medium workload (for me). The topics are interesting (to me).

Just recognize that is is really a "Compilers for Embedded Processors" class (as most of the optimizations have heavy compiler involvement). If you (like I was) are expecting this to be "optimizing applications for IoT" that's not what this is. It's a layer below the applications. It also helped me fall in love with compilers.

Good luck!

I got no background in computer science, how ever this is a very interesting class for learning about computer architecture and compilers, I certainly learned a lot. The TAs always reply to your question almost immediately and there is a 1 week class that is pretty good, it makes you feel like you are physically there. It is not an easy class, and for the projects and homework's, it doesn't used Bonnie (the software that gets you project graded before submitting, which allows you to catch dummie mistakes). I lost points in most of the homeworks for getting confused in dummy things, instead of not understanding the subjects and at least for me the material was overwhelming (although very interesting and well explained). I really recommend this class for someone that is up for a hard but introductory class.

This was my second course and overall, I liked the course as it covered computer architecture basics , Compiler basics and register allocation phase of compiler. The second half of the course covers papers presented by Dr.Pandey which includes different optimization techniques that embedded systems can apply for register allocation. The lectures do a good job of explaining the idea behind each paper. Homeworks and Project 1 are certainly challenging and will easily take entire weekend. Prior knowledge of C++ , Python and Computer Architecture is certainly required to succeed in this course. There are some inconsistencies in lectures and homeworks, so make sure that you clarify everything from TA. TA's are usually responsive and Dr.Pandey holds office hours every week. I would recommend this course if you would like to learn more about compiler backend.