This contains thoughts on each course I took at CMU. Similar pages: 1, 2, 3, 4, 5, 6, 7, 8, 9
Degree: BS in computer science with concentrations in computer graphics and computer systems. I also like math/algorithms/languages, but don’t focus on them.
Pre-CMU: I entered CMU with an extensive programming background in systems and some real-time graphics, as well as a decent undergrad-level math background. I didn’t have any competitive math/programming experience.
☆: courses which I thought were worth attending CMU for. Courses without a star are still worthwhile unless stated otherwise, but one could find similar content/experiences at other universities.
- TA: 15-466 - Computer Game Programming
- I wasn’t planning on TAing this semester, but the professor needed someone to join last minute, so I did.
- Ended up being pretty fun and not a lot of work. Check out the final games!
- ☆ 10-414: Deep Learning Systems: Algorithms and Implementation
- Cool class - you build your own version of PyTorch via the assignments, use it to implement ML models, and extend it as a final project.
- This was the first offering of 10-414/714 (previously 15-884 with only TQ) and the assignments had some annoying issues, but it will be a solid class once cleaned up a bit.
- I registered without having taken an intro ML class, which ended up being fine. The lectures go over (albeit quickly) all the necessary ML knowledge.
- 15-591: Independent Study in Computer Science
- Investigated sampling strategies for differentiable rendering. I didn’t get very much done, but I implemented some new ideas in mitsuba and got results that…would be interesting if explored further. Here’s a poster.
- Worked with Adithya Pediredla and Ioannis Gkioulekas of the CMU imaging group. I didn’t interact much with the rest of the group, but discussions were generally enlightening.
- 17-363: Programming Language Pragmatics
- A nice blend of programming language theory and practical applications, though not super deep on either front. Work is roughly half theory/proofs and half implementing a compiler for a subset of Typescript.
- Doing PL modeling and proofs in a theorem proving tool was interesting and (obviously) rigorous, though the research-quality implementation of SaSyLF sometimes got in the way.
- This was also a first offering. Some assignments were unintentionally time consuming, but this will also be a solid class once cleaned up a bit.
- However, I don’t recommend taking it after 15-411, as the compiler implementation assignments ended up being mostly redundant for me. I would have gotten more out of a theory-only class like 15-312, but I didn’t really want to subject myself to the workload.
- 79-395: The Arts in Pittsburgh
- Pretty fun class; mostly consists of attending cultural events in Pittsburgh.
- Nearly all of the available events this semester were musical, which was unfortunate as I would have preferred more museum/theater trips.
- There were only a few writing assignments, but their grading was non-trivial.
- (Dropped) 11-485: Introduction to Deep Learning
- Exudes an attitude of being very difficult and expects to be your #1 priority, but is actually just not a good class. Or, at least, I was not in the target audience—the class is populated with hundreds of questionably prepared MS students.
- Lectures attempt to get into ML theory, but a lack of required math background precludes satisfying explanations. Lectures instead spent hours on implementation details I found unnecessary and boring—I learned equivalent content about 10x more efficiently in 10-414.
- The quizzes were mostly exercises in deciphering what the questions were asking (or repetitive computation) rather than understanding the theory. They allowed multiple attempts to compensate for the unfairness, which meant you would actually just do the quiz twice.
- The implementation assignments were pretty well structured, but often devolved into numpy index-bashing. The practical ML assignments gave familiarity with implementing real models in PyTorch, but 90% of the work was tweaking parameters and waiting hours for training results.
- I found the professor pompous and condescending. Some people like him, though.
Workload: moderate, light after dropping 11-485
Notes: Graduated. Felt pretty burnt out this semester; finishing degree requirements is not very fulfilling. Decided to postpone PhD applications until fall
2022 2023 (?).
- TA: 15-462 - Computer Graphics
- Was a bit less interesting this time since no big changes were introduced. Will probably not TA again in order to free up more time for research work.
- This was the second semester we ran a course discord server, and it was quite helpful for facilitating student interactions and getting people to help each other. It produced several enthusiastic students who will be new TAs and/or Scotty3D contributors.
- Overall, my previous thoughts on TAing still apply.
- ☆ 15-400: Research Practicum in Computer Science
- Implemented various strategies for computing closest point queries and analyzed their performance on both the CPU and GPU. I found some interesting results that diverged from previous work on high performance ray tracing, but did not find a panacea for closest points. Here’s a report.
- Worked with Rohan Sawhney and Keenan Crane of the CMU Geometry Collective. All of the GC PhD students are generally very knowledgeable and fun to talk/listen to.
- Struggled to find energy for this project during the first half of the semester, but was able to focus more during the second. Combining the latter part (GPU analysis) with my 15-418 final project helped make time.
- 15-418: Parallel Computer Architecture and Programming
- Teaches a lot of interesting and useful content. The assignment on writing a CUDA circle rasterizer was pretty cool.
- I don’t think the class was run very well this semester—the other projects were lackluster and the course staff weren’t very attentive.
- The syllabus spent more time on architecture (e.g. cache coherency, interconnections, heterogeneity) than I would have preferred, but those parts were still reasonably interesting. I enjoyed the parts on parallel programming models, ILP, GPUs, synchronization, lock free code, etc.
- I would recommend the class to people who want to take exactly one systems elective, as understanding how to achieve high performance through parallelism is broadly useful. I think it’s also a good topic as a part of the systems concentration, but not vital, as the content could be learned on-demand. 15-410 covers low-level concurrency in far more depth.
- 15-464: Technical Animation
- Very cool content. The lectures trace the history of research in animation (some were a bit boring, though).
- I learned a lot about simulation, which was the main reason I took the class.
- Assignments include two small projects and a final project, all of which provide opportunities to explore topics of interest. I implemented various inverse kinematic algorithms for the first, mass-spring cloth for the second, and position based fluid simulation & rendering for the final. I added each of these features to Scotty3D.
- Students write a lecture blog.
- ☆ 15-468: Physics-Based Rendering
- I quite enjoyed this class and learned a lot after the first 1/3rd (which was mostly 462 review).
- Ioannis (Yannis) is a good lecturer and does really cool research.
- Programming assignments were too short, but some more advanced ones will be added in later years.
- Homework effectively emphasized fully understanding each topic’s mathematical underpinnings.
- The reading group was quite interesting and gave a window into contemporary rendering research.
- The final project was a good opportunity to explore an interesting advanced topic. I implemented a real-time RTX path tracer, which produced some great results. I’d like to do more projects in this area - BDPT, (PSS) (M)MLT, specular NEE, volumetric/spectral/polarized/time of flight rendering, and differentiable rendering were all intriguing.
- This was the first time a rendering class has been offered at CMU in over 15 years, so it wasn’t fully polished, but I thought it was run well.
- 33-120: Science and Science Fiction
- Similar to experimental physics, since I had the same professor for both courses.
- Easy and occasionally fun. I enjoy sci-fi.
Other: geometry collective/graphics lab meetings. A period of severe personal issues (resolved).
Workload: 2/3 light, 1/3 heavy
Notes: I finally got to take classes purely in my area(s) of interest, so I enjoyed this semester more than others. Doing 3.5 final projects at once (plus TAing) was a bit much—I wasn’t able to dedicate as much time to each as I would have liked to. But, I still did well and am pretty happy with the results. I also got extremely good TA feedback again.
- ☆ TA: 15-462 - Computer Graphics
- Put new codebase into production. This created extra work for myself in fixing bugs, but it went quite well overall. Students produced some way cooler results with the new framework!
- Otherwise same thoughts on TAing as last semester.
- 15-300: Research and Innovation in Computer Science
- Learning more about my area of research (graphics and geometry processing) was great!
- More of a gen-ed class (it fulfils the technical writing requirement), and some parts were boring.
- Set up a research project with the Geometry Collective for next semester.
- Wrote and presented some pretty good technical write-ups.
- ☆ 15-411: Compiler Design
- Compilers is the other infamous-workload systems class. My experience is maybe not representative, but I found it far easier and less stressful than OS. Unlike OS, you’re given thousands of test cases, and if your compiler passes all of them, it gets full credit. No more combing through code for concurrency mistakes for days on end.
- Interesting content, although the lectures tended to be more abstract and advanced than was required to implement the projects.
- Projects require building up a decent sized codebase from scratch over the semester, which is good for learning to technically manage a significant project. You can choose your implementation language: I learned Rust for this class, which turned out to be interesting and useful.
- As with OS, you need to be able to work well with your partner.
- 15-451: Algorithm Design and Analysis
- I wish I could say this was a great extension of 15-210/15-251, but it really wasn’t. Some of the topics were interesting to me (e.g. computational geometry), but others were either review from previous courses or not relevant to my interests.
- The professors (Gary Miller + Klaus Sutner) were a bit out of touch, as they typically teach grad-level classes.
- Had some programming homeworks in the style of competitive programming, which were cool problems.
- Class midterm average - 50% (lol). Substantial curve at the end.
- 21-355: Principles of Real Analysis I
- Was less interesting than I had hoped, but still useful for formalizing my thinking about basic continuous math. The course serves as a pre-requisite for all upper-level continuous math courses.
- Not too much work in of itself, but it pushed my workload from being often stressful to being basically always stressful, so I kind of regret taking it. I was originally taking it to complete the math minor, but I’ve now decided to do the new graphics concentration instead.
- 60-125: Introduction to 3D Animation
- Cool class and pretty fun! You learn each step of the 3D animation pipeline (mostly for film, but also games) by doing it yourself. You assemble everything you’ve built up over the semester into a final animation.
- A surprising amount of work—every step is quite involved. I wish I had more time available to work on the final piece, but I still learned all the content.
- Good to experience the art side of computer graphics.
Other: Started working with the Geometry Collective.
Notes: It was much harder to stay motivated in online classes outside of my preferred areas—did many things last minute or late in the latter half of the semester. I probably should have taken fewer classes, but I did end up doing well in all of them. I also got extremely good TA feedback.
- ☆ TA: 15-462 - Computer Graphics
- See general advice regarding TAing below (recommended).
- Working with students at office hours is often fun, though debugging their code can be difficult.
- Over the 2019 winter break, I started working on re-writing the course codebase to be much faster, cleaner, and less confusing. I hope to deploy it fall 2020 (now deployed!). Support for the project was very encouraging, although I did not really receive any guidance. Being able to have that much influence over the course on my own was surprising—it’s not the norm for larger core courses with more formalized processes.
- ☆ 15-259: Probability and Computing
- Very well run, in-depth, and fast-paced. For CS majors, I highly recommend it over the other probability options.
- Includes CS applications of probability such as randomized algorithms, performance modeling, and Markov chains, which are all relevant to many areas of CS.
- Mor is great. She is experienced, enthusiastic, and cares about student success.
- Moderate workload: one problem set every week. Exams are pretty easy.
- ☆ 15-410: Operating System Design and Implementation
- Infamous for being the highest workload class in CS. It really is a lot of work, but people do exaggerate somewhat.
- The staff will not make design decisions for you or debug your code—you must learn to design, test, evaluate, and debug a complex low-level project, from scratch, yourself.
- Much of the work is debugging—if you’re not yet an effective debugger, this course will make you one.
- The midterm/final were difficult and stressful, and I don’t think they should have existed. The grading scheme was also very opaque…
- You need to be able to work well with your partner. Group work issues are common.
- ☆ 15-458: Discrete Differential Geometry
- More of a math class than a CS class, but the applications (implementing algorithms on real meshes) made results tangible and very rewarding.
- Overall my favorite math class ever—I highly recommend it if you have any interest in geometry.
- Keenan is great - in this class especially, his slides, diagrams, and animations are very elegant. They’re used to teach this content all over the world.
- Light workload: one moderate problem set + one short programming assignment every 2 weeks. [2021 update: apparently the problem sets are a lot more work now.]
Workload: moderate to heavy, depending on when an OS project was due
Notes: Everything this semester has a star—all are recommended. Coronavirus arriving midway through the semester caused much turmoil, but PnC & DDG finished more or less normally. While OS changes were mostly bungled—the majority of our course grade was unknown after the final grading deadline—kernels got completed and end-of-semester work was somewhat reduced. After taking it, I didn’t feel that OS deserved its reputation as the systems class to take, as I found a good portion of its difficulty to be incidental and not really contribute to learning (although I may also be biased from a poor group work experience). Even so, OS does teach one a lot about low level design, debugging, and especially concurrency, so it’s worth taking if you want a systems concentration. Otherwise, eh…there are likely better uses of your time. Finally, note that OS is not recommended as a first systems elective—especially as a sophomore—and I’d agree with that unless one found 15-213 easy.
- 15-210: Parallel and Sequential Data Structures and Algorithms
- Algorithms are cool, and you do a lot of problem solving with them. This class was another solid theory offering, but was not as special as 15-251.
- As with 15-150, the course is taught in SML, and is similarly not super difficult for those who grok the functional style.
- There was less emphasis on parallelism than the name might suggest—this just meant that you analyze the span as well as the work of each algorithm.
- 15-213: Introduction to Computer Systems
- Gigantic class and hence hard to run efficiently, but covers essential systems topics very well. Should be taken by anyone going into software engineering, even if not systems-oriented.
- I was already familiar with most of the topics (as well as programming in C from scratch), so it didn’t take up much time.
- ☆ 15-462: Computer Graphics
- Deep but accessible lectures, rewarding and complex projects. Good introduction to many sub-fields within graphics.
- Unfortunately almost totally lacks real-time graphics—the only project that hits on these topics is a software SVG rasterizer.
- The codebase was a mess—but I have fixed this.
- Keenan Crane is excellent. Nancy Pollard is also great, but tends to give less engaging lectures.
- 15-295: Competition Programming and Problem Solving
- Basically a club rather than a class (3 hours a week).
- Doesn’t teach much content - you just solve problems. [2021 update: there is now 15-195, which teaches more content.]
- I didn’t have any competitive programming experience (and wasn’t extraordinarily good at it), but with a 15-210 level of algorithms knowledge I was able to get by without putting in much time outside of class.
- 33-104: Experimental Physics
- Teaches laboratory skills, but the physics content is quite basic.
- Minimal homework if you finish the lab tasks during class.
Workload: moderate to heavy, depending on how many due dates coincided
Notes: My first-year advisor wouldn’t let me register for graphics without the pre-requisite (15-213), even with instructor permission, but I got into it anyway by talking to the assistant dean. My advisor from second year onward was much more flexible. Moving into an off campus apartment made everything significantly better—from then on I always slept for 8-9 hours.
- 15-150: Principles of Functional Programming
- I think everyone should have to take at least one class in a functional language, and this was a great introduction.
- Not super hard if you quickly grok functional reasoning.
- Many assignments involved proofs for which grading was unnecessarily pedantic and occasionally incorrect.
- ☆ 15-251: Great Theoretical Ideas in Computer Science
- Very interesting overview of many topics in CS theory. Enough depth to legitimately understand and apply the topics to other areas, but not so much as to make you hate the less interesting parts.
- I didn’t enjoy the weekly homework writing session: it felt like a test every week. I would have preferred the opportunity to write-up the problems on my own, which I didn’t do for about half the weeks. However, I did find writing sessions far preferable to the more traditional exams.
- Beyond the solo problems, the homeworks were usually very difficult. I have heard this semester (Venkat + Vipul) was unusually hard and included some content that’s since been moved into 15-252.
- The hard problems are meant to be worked on in groups—prioritize finding a good one.
- 21-268: Multidimensional Calculus
- Overall, this is a good course, but for me was early morning and pretty boring.
- It gave a more rigorous treatment of calculus than what I already knew, but still contained too much review. I probably should have taken 21-269 (Vector Analysis). However, I think this semester (Schaeffer) was easier than average, so this may have just been bad timing.
- 80-135: Introduction to Political Philosophy
- Highly recommended if it fulfils a gen-ed requirement you need.
- A lot of (interesting) reading but light writing.
- Derek Gray is engaging and enthusiastic. Philosophy TAs are also interesting.
- 80-150: Nature of Reason
- Pretty useless, don’t take this. Minimal work, though.
Workload: moderate, but often felt heavy due to not sleeping enough
Notes: I hated living in a dorm.
- 15-122: Principles of Imperative Computation
- An important class to take, but was almost entirely review for me. Should have skipped.
- Practices like defensive programming with contracts and invariants are valuable for all future coding.
- ☆ 15-151: Mathematical Foundations of Computer Science
- Very well run: Mackey is a great lecturer/leader.
- Necessary and sufficient preparation for CS theory, algorithms, and proof-based math.
- Pretty straightforward if you have background in competitive math, but difficult otherwise. I never did competitive math, but had already taken a logic class, so it wasn’t bad.
- 21-241: Matrices and Linear Transformations
- This semester had a SCS specific section that included short programming assignments implementing results in Python. I don’t think this added much.
- Included some advanced(ish) topics, including SVD and a final project on spectral clustering. Those parts were interesting and new.
- Overall was too much review for me: I should have taken 21-242 (Matrix Theory).
- 76-102: Gothic Literature
- Pretty standard literature class. Topics vary depending on the professor and semester.
- Good alternative to 76-101 if you enjoy reading & discussion.
- 85-102: Introduction to Psychology
- Exam grading made it secretly the hardest class at CMU.
- Minimal work outside of class, though.
Notes: I’m still annoyed that my first-year advisor denied my transfer credit for 21-241, 21-259, and 15-122…I really didn’t need to re-take those courses. For 15-122 in particular, my syllabi included all of the content, but my request was denied due to one of the courses having been offered online, despite being a normal university course! (Funny how their stance on online courses changed in 2020…) I also regret not taking the honors first-year math track (21-242 + 21-269). I wasn’t selected for 21-242 based on the math maturity survey, but I think I would have gotten more out of those courses than 21-241 and 21-268. In a perfect world, I probably would have taken 15-150/15-151/21-242 first semester, 15-213/21-269/elective second semester, and 15-251/15-210/elective third semester.
Some Advice for First-Years
- Immediately doing research isn’t the best idea: even if a professor gives you a real project, your knowledge will be pretty limited until you’re able to take CS electives. I would instead recommend focusing on doing excellently in/more of the core courses. Over the following summer, however, getting into research is a great idea if you don’t want/get an internship, since first year internships are unusual.
- Many people recommend taking fewer classes to make time for other cool things, so I’ll reiterate that, especially if you are interested in research (but, not implying that research is the only other option). However, to get into these ‘other things,’ I would encourage trying to stand out in classes whose content you are particularly interested in, doing outside projects, becoming a TA, or any other activities that can build a relationship with faculty—even if it means putting in a little less effort in other areas. This presentation from ex-CMU (now Stanford) professor Kayvon Fatahalian discusses what to optimize for in more detail.
- TAing is a rewarding experience: you can deepen your understanding of your subject, teach others about what you enjoy, and even personally influence course/curriculum development. I will note that the latter is more difficult to do in core courses, which tend to be larger and more set in stone. Unfortunately, you do not get paid very much—it’s not worth it monetarily, unless it gets you a job.
- Don’t expect transfer credit for other university courses…