A Review Of Udacity's CS212

By Max Li | Published: August 22, 2012

I spent the past week or so going through Udacity’s CS212 class (Design of Computer Programs). The course is taught by Peter Norvig, the director of research at Google and one of the instructors of the original online Stanford AI class.

When I began, I wasn’t too sure how it would go. I found the previous two Udacity courses quite varied in quality. The introductory course, CS101, was of quite good quality and had both relatively standard and challenging questions as homework/exams. Contrary to that course, the advanced course about AI for robotics, CS373, felt extremely watered down; it practically had the same difficulty as CS101, if not even somewhat lower. I was quite disappointed by that offering. However, CS212 turned out to be much more similar in quality to CS101.

CS212 is about the design of computer programs. To clarify, it focuses on how one should approach the design of a program/algorithm to solve problems; it wasn’t really a course on software engineering. It apparently was meant to be a follow-up to CS101, though it is likely much more difficult than most second courses in CS (in fact, it is marked as an advanced course by Udacity, despite only being a 200-level course). There were quite a few times where I initially didn’t have much of an idea on how to approach a given problem. There was a fair bit of going back to re-watch a lecture video and/or staring into space thinking about the question. I found this nice (but perhaps a little painful, but the good kind of pain). In addition to presenting techniques to solve problems, the instructor presented many new Python constructs, though I feel some of them were a bit too quickly explained if one didn’t have functional programming experience (though this is just my impression).

The difficulty of the course is something that apparently caused many complaints on the forums when the course was originally released a few months ago. I agree that the course is perhaps mislabeled, but I appreciate the fact that for the most part, the course retained its nontrivial difficulty throughout (though towards the end of the course, the questions during the lessons seemed to be getting easier (perhaps an attempt to appease the masses), but the homework problems didn’t seem to drop significantly in difficulty).

However, there were several weaknesses to the course. There were some glitches in the marking. In particular, for one question on the final exam, the grader was extremely picky about the ordering of part of the output (which was not specified in the question), and I wasn’t able to track this down without reading many threads until I saw someone else having the same problem.

But not all the problems were technological. I had quite a few issues with the overall pedagogical design of the course. For instance, there were some questions in the course where you were asked to write a function. Except since you didn’t necessarily have all the functions this function would depend upon, your only option to verify you were correct was submitting it to the system. If you got it wrong, your only option would be to figure out the error by staring at your solution (and sometimes you just have to give up and look at the answer, finding out you interpreted the question differently).

Another negative aspect was the quantity of material in each unit. Most units had an appropriate amount of new information, but there was one unit where Peter tried to cover far too much. For example, he tried to explain parsing, and as someone who has already taken a (real-life) course covering some parsing and formal language theory, I found his explanation both oversimplified and rushed. I feel like there would be an equal amount of confusion without that knowledge.

Overall, despite these problems, I found the course quite rewarding. I developed a fair bit of problem solving ability and learned some Python. CS212 is a relatively worthwhile course, probably as a third or fourth course in computer science.

Overall Rating: 7.0 / 10.0