Jan 2023 Update: currently restructuring and rewriting most of the content
- Comments on each course is now split into four parts:
- about the course materials themselves
- about teaching and infrastructure
- about my experience and learning strategies
- other miscellaneous thoughts
- All reflections are moved to a separate section, including the following aspects:
- navigating career
- navigating college life
Degree: BS in Information Systems + additional major in Computer Science
Background: I entered CMU (Dietrich) with a decent background in humanities and social science, and wanted to study psychology or cognitive science at first. I didn’t have much, if any, STEM background other than several years of experience in Pascal and a little knowledge of Java (from APCS) and Python.
Table of Contents
☆☆ are courses I recommend taking, on top of having good or useful content.
- ☆ 15-466 Computer Game Programming
- 15-451 Algorithm Design and Analysis
- 17-363 Programming Language Pragmatics
- 3rd-time TA for 15-210
- Full time job hunt: for more details, see my other blog post New Grad SWE Job Hunt Advice
Workload: 36 units. Time-logging suggested that I spent 35-40 hrs per week on coursework. Main source of stress came from job hunting and the uncertainty of which.
- 21-266 Vector Calculus for Computer Scientists
- 67-373 Information Systems Consulting Project
- 17-356 Software Engineering for Startups
- 15-281 Artificial Intelligence: Representation and Problem Solving
- 4th-time TA for 15-210
- ☆☆ 15-440 Distributed Systems
- professors: Yuvraj Agarwal, Rashmi K. Vinayak
- Covered most fundamental design principles and techniques of distributed systems, many of which crucial to modern day software engineering, since many SWEs will be working with a distributed system even if they are not working on one.
- Taught in Go for fall and Java for spring. Go was a bit unintuitive to work with at first, but I appreciated it more over time.
- Working through the projects was just a huge battle with all sorts of concurrency issues. Read more about them here.
- teaching and infra:
- Most content was explained decently clearly in lectures. The slides were detailed but were not a substitute for lectures for the hardest parts.
- Due to the shortening of the semester and lack of corresponding readjustment, the course had a pretty stressful schedule and received a lot of complaints that semester.
- OH was useful for written assignments and getting advice on how to start for the coding projects. However, it’s more efficient to rely on yourself (and your teammate) for debugging.
- Some written questions were phrased ambiguously, but not otherwise challenging.
- Thanks to my teammate, I had very good experience with the two group projects. The takeaway is: find a good teammate.
- The two harder projects took around 20 hours per week. The exams were easy.
- Not too overwhelming overall - a good choice as one’s first systems elective.
- 15-459 Quantum Computation
- professor: Ryan O’Donnell
- Discussed the theoretical side of quantum computation, including some of the most fundamental quantum algorithms.
- No physics, a lot of CS theories and math - especially linear algebra.
- teaching and infra:
- The professor taught well, and was accommodating. OH is also very useful for getting conceptual or homework help.
- Turned out to be quite a bit harder than I expected, but it’s not objectively very challenging if one is good at linear algebra and thinking abstratly (I’m not).
- It would have been easier had I taken 251 before it, which felt like much more crucial of a prerequisite than 210.
- Homework was optional and was harder than the exams. Without homework, the course took <10 hrs per week, but with homework it took quite a bit more.
- Overall positive experience, but I don’t think one should take it without being genuinely interested in either quantum computing or CS theories.
- 67-262 Database Design and Development
- professor: Raja Sooriamurthi
- Covered the basis of relational models, basic and intermediate SQL queries, important database design principles, and MongoDB basics.
- The course is meant to teach you how to use and interact with databases while having a high-level idea of how they work under the hood. It’s not a substitute for courses that cover database implementations, such as 15-445.
- teaching and infra:
- Raja is a nice and caring professor, and had given good life advice. The teaching itself was clear but too slow-paced for me.
- A chill class overall, but it’s mostly because I already have experience with much of the content.
- ☆ 76-270 Writing for the Professions
- professor: Peter Z. Mayshle
- The first project is about job application materials. The remaining three had very flexible topic choice (I don’t know how much this flexibility varies among different professors).
- teaching and infra:
- The professor was responsive and accommodating. The class was small and discussion-heavy.
- A pretty fun class because I could write about topics that I’m actually interested in.
- Would have benefited from the course even more had I taken it in my sophomore year - so I suggest taking it early.
- 1st-time TA for 15-210
- see Teaching Expereince for more comments
Workload: 39 units. Heavy during the first half due to the hardest 440 project and several other life adjustments, manageable in general.
- ! 15-251 Great Ideas in Theoretical Computer Science
- Covers many important theorectical foundations of CS, such as computability and complexity, randomized algorithms, approximations, etc. There’s a lot of math involved (e.g. set and graph theory), and a huge part of the class is reading and writing proofs.
- This class has a reputation for being very hard, and I mostly agree with that. Some parts did give me quite a hard time (mainly countability and approximation), while others were relatively easier to understand (since it has some overlap with 210). For what it’s worth, the time I spent on it is definitely more than other core classes.
- I can’t tell if I am a fan of the writing sessions, where instead of submitting the assignment, some random questions from it are picked and one needs to write down the answers in a quiz setting. On one hand, as someone with test anxiety, I needed to spend way more effort to prepare for the weekly “tests”. On the other hand, it did make exam preparation way less stressful, since I felt that sufficient understanding of the homework problems makes exams pretty trivial.
- Ada is probably the most devoted professor I have met at CMU so far. He has definitely spent a lot of effort into making 251 a good course, and he is very good at explaining and motivating complext concepts. The course also has a good support structure. One would definitely enjoy this course if they are interested in math and theoretical CS, even though it would take non-trivial effort to do well in it regardless.
- 15-330 Introduction to Computer Security
- The course has four main parts: security concepts, cryptography, network security, and human factors. I took it both out of interest and because I believe it’s a field with practical importance that deserves more attention than it’s getting.
- The first two assignments (exploiting C programs and cryptographic primitives) turned out to be pretty hard and took me way too long to finish. It almost seemed like mission impossible to fully understand cryptography and I literally got more stuck on them than 440 projects. The cryptography exam was also brutal. Things chilled down a lot after the crypto part though.
67-272 Application Design and Development
70-332 Business, Society and Ethics
- (TA) 15-210 Parallel and Sequential Data Structures and Algorithms
Workload: objectively lighter than the previous semester but the work was more frustrating
Reflections: I spent a lot of time this semester reflecting on the series of choices I made in the past few years in terms of academics, future career, and just life in general, that led me to where I am right now, and identified the gap between who I am and who I want to become. Closing that gap requires non-trivial effort, the exact reasons of which does not fit into the theme of this post, so I won’t go into details here (but maybe in a separate post). Luckily, I am making continuous progress (albeit slowly).
- Returned to Amplitude for a second backend SWE internship on the same team.
- ! 15-210 Parallel and Sequential Data Structures and Algorithms
- After 15-150, I thought I would hate this class, but that didn’t really happen. Learning algorithms and solving problems functionally was still challenging, and I had to put in quite some effort and relied heavily on office hours. It’s rewarding to figure a problem out, but the process did get very frustrating at times.
- The algorithmic content covered in this class is pretty useful for technical interviews. SML also became more tolerable when I’m not only learning about the language itself.
- ! 36-290 Introduction to Statistical Research Methodology
- A research training course for sophomore statistics students. Highly recommended if you’re interested in doing statistics or data science stuff - extremely useful.
- Heavy focus on application of statistical learning methods (supervised vs unsupervised, regression vs classification, etc.), with a lot of programming in R.
- 36-350 Statistical Computing
- A good course to practice R fundamentals and common libraries for data analysis, and learn some slightly more involved topics (simulation, optimization, etc). It helps one become decent at programming in R with a very reasonable amount of effort. Some overlap with 290.
- Last few weeks were about SQL basics which is also useful.
- 36-401 Modern Regression
- This course seriously made me question my major choice and pushed me toward transferring out of statistics, although it’s obviously not the most important reason.
- A big part of the course is the mathematical basis of linear regression models. Don’t think I remember a single thing about the content other than it being boring and feeling meaningless to me.
- 79-104 Global Histories
- The topic was genocide and weapons of mass destruction. Fairly interesting. I enjoyed all three required books and would recommend them: Ordinary Men (Holocaust), Machete Season (Rwanda genocide), and Thirteen Days (the Cuban Missile Crisis).
- (SI Leader) 21-241 Matrices and Linear Transformations
- I applied to be an SI leader after my first semester because I wanted to lead 21-127, but I ended up being assigned to 241.
- Put a lot of effort into it and got really good student feedback.
Major: Still in stats ML, but applied to transfer to information systems.
Workload: pretty heavy during the first half due to projects, slightly better after I had some exposure
Reflections: I finally thought about my career path seriously, and leaned toward software development rather than data science as I used to, despite having zero development experience. Hence, I started working on various web projects and applying to SWE internships, although with no luck (applied to 70+ places, got three OAs, failed all of them). Later in the semester I decided to transfer to IS since it aligned with my career goal better.
- ☆☆ 15-213 Introduction to Computer Systems
- The content gets more and more interesting deeper into the semester, but also more challenging. I didn’t quite know how to program in C at the start of the course, and things like memory management and concurrent programming took time to sink in.
- Similar to 210, the labs were time consuming and could be frustrating since I was new to system programming and low level languages, and was yet to form very good coding habits. However, finishing them felt rewarding and they definitely improved my coding and debugging skill.
- It also made me interested in computer systems. In hindsight, the course was useful and worth the amount of effort I put in.
- ! 15-388 Practical Data Science
- Another very useful course for people interested in data science, requires rather solid Python skills and focuses heavily on application (as the name suggested). Covers all the major aspects of data science (collection, modeling, etc). The statistical and machine learning modeling part has some overlap with 36-290.
- Well taught content and decent workload (given one is proficient in Python). There are two projects and Zico Kolter was very flexible about the topics, so I got to work on things that I found interesting (Overwatch Stats Analysis), which was great.
- 67-250 The Information Systems Milieux
- First half of the course focuses on the business aspect of IS, with a lot of case studies and theoretical/methodological stuff. I didn’t like it, and I would never want to work on something like the Tesla case study project again.
- Second half of the course is an introduction to HTML/CSS, JS and SQL. A good overview but the pace was way too slow for me. The final web dev project also made me realize I wasn’t very fond of frontend stuff.
- 36-315 Statistical Graphics and Visualization
- Teaches you how to make statistical visualizations that make sense in R and think critically about them. Also covers the basics of data analysis and model inference. Some overlap with 388.
- Chill workload. Zach Branson is a very nice professor who is willing to make quick changes according to students’ feedback.
- 65-203 Applied Quantitative Social Science II
- Second year seminar for students in the QSSS program, featuring a lot of guest lectures on a wide variety of topics. A good chance to learn about all the cool social science research going on in Dietrich and connect with peers. It was unfortunte that I was not able to attend the seminar synchronously because of time difference.
- (SI Leader) 21-241 Matrices and Linear Transformations
- Co-leading the SI session with someone else somehow made it less fun for me. Also had less attendance comparing to last semester.
Major: Transferred into information systems.
Reflections: A semester where things magically started getting better. I received an ideal internship offer on the first day of the Chinese New Year, so throughout the semester I didn’t have to worry about much outside of school work. Getting into IS did mean I could no longer graduate early though.
- I interned remotely at Amplitude as a backend software engineer, and was surprised by how much I grew during my 12 weeks there. At the beginning, I relied a lot on my mentor; being uncertain about the quality of my work, I would consult her about everything big or small. But I quickly realized that I could figure out most things on my own and often notice details that others have overlooked, so I became more confident in my abilities and that formed a virtuous cycle.
- I ended up finishing my internship projects a lot faster than expected. Around the same time I discovered a bug in production where a feature was optimized incorrectly, which resulted in wrong computation of data, so I took on this unexpected task of fixing it. During the last few weeks, I worked on a couple smaller features, including a hackathon project which won the 4th place.
- I decided to return next year for another internship for a few reasons. First, I liked the culture there and my team was especially nice and fun to work with, which I value a lot. Also, I felt like I could (and did) make an impact, because regardless of seniority, people were supportive and valued my opinions. For example, I got to work with our Chief Architect and several other senior members for the hackathon project and made important contributions. Lastly, the company was quickly expanding at that time, launching new products and preparing to go public, so there would be a lot of opportunities for me to learn new things while leveraging my existing knowledge to reduce onboarding overhead.
- 21-127 Concepts of Mathematics
- Covers the fundamentals of discrete math, including logic, proof techniques, basic set theory and number theory, etc. I’m not really a math person, but I found the content decently structured and well taught, and useful in many future courses.
- The course is heavily proof-based. First 1/3rd of the course gave me a rough time because I wasn’t very good at writing rigorous proofs, but it got much easier once I got a hang of it.
- 36-202 Methods for Statistics and Data Science
- I wasn’t yet into data science at that time, but definitely found the content more engaging than AP statistics. A very easy course that covers quite some important fundamentals of statistics and provides a little R exposure.
- 76-100 Reading and Writing in an Academic Context
- As an international student, if I didn’t want to take it I would need to pass the placement test to skip it, but I didn’t. In hindsight, it might be a bad idea because I don’t think I learnt anything new from it, although it did help me brush up on my writing.
- Most of the lower-stake assignments centered around basic writing skills, such as writing synthesis, presenting arguments, etc.
- 66-106 Quantitative Social Science Scholars First Year Seminar
- Covers the basics of social science research with quite some R exposure - some overlap with 202. Moderate amount of reading and lectures are discussion-based.
- The seminar was also a good chance to know other peers in the QSSS program.
- 15-112 Fundamentals of Programming (Dropped)
- I didn’t need to take it, but I was worried that my programming fundamentals was not solid - I barely remembered anything from APCS.
- Dropped it five weeks into the semester because the course annoyed me more than it benefited.
- CMU Overwatch team
Major: DC undeclared, leaning towards statistics by the end of the semester. Due to various reasons, was also considering transferring to SCS.
Workload: light once 127 clicked
Reflections: In hindsight, I should have just taken 15-122 and 76-101 this semester. But the transition from high school to college in another country turned out to be harder than I expected, so I don’t completely regret not pushing myself harder.
- 15-122 Principles of Imperative Computation
- C (well, C0) is hard with no previous exposure, and it takes time for things to start making sense.
- Lectures were quite boring, although objectively speaking the content is useful especially for someone who hasn’t systematically learnt about data structures like me.
- Writing contracts and invariants and proving correctness was somewhat interesting of a concept, although it did get annoying at times.
- 21-241 Matrices and Linear Transformations
- Not quite interested in linear algebra, but it was tolerable since the content was easier than that of 21-127 and the workload was also lighter.
- 76-101 Interpretation and Argument
- Heavier focus on analysis and more involved writing techniques comparing to 76-100.
- From what I heard, people’s experience in this class varies highly depending on which section they are in, since professors and topics are different. Even within the same section, the professor may have preferences for certain writing styles. (Same thing holds for 76-100)
- 73-102 Principles of Microeconomics
- I thought I was interested in economics until I took this course - it’s not the course’s problem though. It’s fairly easy, and my professor (James Best) was humorous and explained things well. Quite some overlap with AP Microeconomics.
- 99-251 Seminar for Supplemental Instruction
- Back then, to become a Supplemental Instruction/Excel leader, one needs to take this training course. Not sure if it’s still the case after the academic development department was restructured.
- Practices some basics of teaching for collaborative learning, supporting academic development and stuff. I just treated it as break from schoolwork.
- ☆ 98-182 (Student Taught Courses) Billiard Games: From Noob to Pro
- Very fun and I enjoyed a lot. Pretty unfortunate that in-person practice was disrupted because of the pandemic.
- CMU Overwatch team
Major: Declared statistics and machine learning because I wanted to do data science related work.
Workload: light until the end of semester where I lost motivation to study because of the pandemic
Reflections: Anxiety hit me hard since the start of the pandemic in China, since my parents were there. Later in the semester I stopped playing for the Overwatch team because I couldn’t handle anything intense or competitive.
- (Summer 1) 15-150 Principles of Functional Programming
- Teaches Standard ML and some core concepts in functional programming. Way too fast-paced since it was only six weeks (they changed it to be 12 weeks in summer 2021). Some ideas are somewhat cool, but too novel for me to be sufficiently comprehended in that short of a time (e.g. continuations/lazy evaluations).
- On top of the concept itself, I also didn’t particularly enjoy learning SML and was often confused by it.
- (Summer 1) 36-225 Introduction to Probability Theory
- Fairly easy with a chill workload, quite some useful knowledge and practice of basic probability theory, random variables and distribution functions, etc.
- (Summer 2) 36-226 Introduction to Statistical Inference
- The course content centers using probability to analyze and make inference about data, such as hypothesis testing and linear models, etc.
- Relatively easy with some annoying math, although the content isn’t quite appealing to me.
- ☆ (Summer 2) 33-124 Introduction to Astronomy
- Perfect course for people who are interested in astronomy but don’t want to deal with the math or physics aspect of it too much. As someone who hates most natural sciences, I liked it a lot and learnt a fair amount. The workload was light.
Workload: summer 1 was pretty heavy, summer 2 was chill
Reflections: Worst semester in terms of mental status, resulting in many decisions that I later regretted. This plus how painful 150 turned out to be discouraged me from transferring to SCS. So I was on track to graduate in 2.5 years, but that also pressured me to immediately think about my career goal, which was stressful.
Junior & Senior Year: TA for 15-210 Parallel and Sequential Data Structures and Algorithms
- TAing 210 helped me gain a deeper understanding in its content and appreciate (some part of) if more. That, plus the skill of explaining algorithmic ideas - especially the intuition of which - turned out to be a crucial advantage in my job hunt one year later.
- I have mixed feelings about TAing a core CS class. On one hand, the majority of the students I have dealt with probably took the class out of necessity more than interest in the course content itself, and while I have grown to like the content more, I understand that to many students it is more of a task to be completed rather than a self-motivated learning experience, comparing to students taking electives.
- The problem that follows is: how do I balance these two different and sometimes conflicting goals? For example, when students ask for help on an involved programming question, if I want to maximize their learning experience, I would build up the intuition, ask them to try come up with the actual steps themselves, and come back again once they have more thoughts. However, that’s impractical when there is a 1:15 TA-student ratio, and average wait time for OH easily reaches 1-2 hours per round.
- On the other extreme, I can directly tell them the algorithm and help them understand it. But if you have worked on algorithm problems before, you would know that for such problems, understanding a given solution is very different from coming up with the solution yourself; it takes a different set of skills, and that to achieve the latter is what we want students to get from a course like this, and also what they will ultimately benefit from.
- Similarly, when students ask from debugging help, it’s different to help them find their bugs versus to teach them what debugging steps to take, although I assume this is much more of a problem for 213 TAs comparing to 210.
- After (almost) 2 years of TAing this class, I still can’t say I have found the balance, but I’ve tried different methods that (seem to) have helped, such as intuiting problems to students in large group, reinforcing important debugging methods to them while walking through their code (“Which value is incorrect? Have you printed the variable and traced it? Which line of code led to this value?”), etc.
- On the other hand, because I need to deal with a large number of students with different backgrounds (many of which is non-CS), communication and teaching skills become extremely important. You are not justing explaining why a method works - you should also explain why they should consider this method to begin with, what is the pattern of different problems using this method, what are the alternatives, etc. Students are also different type of learners; some understand calculate costs of recursive functions better by looking at a recurrence tree, while others prefer looking at mathematical formula, and you should cater to such varying needs.
- Beyond technical interviews, all such skills gained from TAing are essential to any technical person working in a non-isolated environment, since you need to explain technical ideas to outsiders, but also learning new concepts quickly from others.
- To summarize, I would highly recommend gaining some teaching experience during one’s time at CMU. I do think TAing different courses are more beneficial unless you want to undertake course development tasks, even though I haven’t follow this suggestion myself (I sticked to the same class for two years without doing more than teaching).