As an engineer who has spent a lot of time on performance engineering, I have to say that this course has a lot of the "cool" parts of the job, but not a lot of the actual nuts and bolts of it. Practical performance engineering is primarily about measuring things.

In large software systems it's not obvious at all where your hotspots actually are and what you actually should do to take care of them. Further, once you do an optimization, you need to be able to make the right measurements to prove that your optimization actually worked. A lot of optimization also involves parameter tuning (eg how many threads to do what), and that is incredibly dependent on having good measurements.

Once you know what to do, the actual optimizations you need to do - even assembly-level tricks - are usually somewhat straightforward in comparison to the measurements you do to get there. If you don't do the measuring, you are going to end up doing a lot of high-effort, low-return work.

I TA’d this course this semester (Fall 2018 - wow the time flies), happy to answer questions.

(Though I’m currently backpacking through the Andes so you may need to be patient)

I am currently trying to prep for SWE roles where my focus would be performance / scalability, so this course is extra topical for me. Thank you for sharing.

Here are some other resources for people interested in improving their understanding of performance:

- "Computer Architecture: A Quantitative Approach" by Hennessy and Patterson. The "Computer Organization" book by the same authors is also good. Both of these resources were extra useful when building deeper intuitions about GPU performance for ML models at work and in graduate school.

- CMU's "Deep Learning Systems" Course is hosted online and has YouTube lectures online. While not generally relevant to software performance, it is especially useful for engineers interested in building strong fundamentals that will serve them well when taking ML models into production environments: https://dlsyscourse.org/

- Compiler Explorer is a tool that allows you easily input some code in and check how the assembly output maps to the source. I think this is exceptionally useful for beginner/intermediate programmers who are familiar with one compiled high-level language and have not been exposed to reading lots of assembly. It is also great for testing how different compiler flags affect assembly output. Many people used to coding in C and C++ probably know about this, but I still run into people who haven't so I share it whenever performance comes up: https://godbolt.org/

Another good course with exercises: https://github.com/dendibakh/perf-ninja

Looks interesting, wish it touched on system and os level optimizations too.

See also The Art of Computer Systems Performance Analysis by Jain.

The statistical parts are very good: self contained and with good explanations. Perhaps a weakness is there isn't much on distributed systems.

He did some Youtube videos as well.

The course looks really interesting, but in my experience of "performance engineering" you very rarely need to know this stuff.

If you want to improve the performance of some random software system you encounter at work, there is normally much lower-hanging fruit available.

First profile the application on as representative a workload as possible. Then fix the accidentally-quadratic loops, stop it from hitting the disk every iteration, add indexes for the worst database queries. If that doesn't at least double your throughput, you are working on an unusually-good application.

[flagged]