Review: Udacity CS101 (Intro to Computer Science)

In a previous post, I laid out what I think are eight ingredients for a great massively open online course (MOOC). My ingredient list grew out of my experience taking two computer science courses through Udacity: CS101 (Intro to Computer Science) and CS253 (Web development). Here’s my more detailed take on the first of these two courses (CS101), using my eight ingredients as a framework.

A swimmingly good experience (Grade = A-)

My overall experience with this course was very positive, and I accomplished my goal (to learn Python). In general, I think it would be a great course for someone looking to learn a bit about programming. For me, it was also terrific as my first MOOC, and set a pretty high bar against which other MOOCs must compete.

In terms of my great-MOOC ingredients:

  1. Content: The core content in this course is solid. It comes from a credible source (David Evans, a CS professor from the University of Virginia with numerous teaching awards) who delivers the content in an engaging way that mixes dialog, historical sidebars, short video lectures and quizzes. The content is up-to-date for the most part, and completely appropriate for an introductory course with no prerequisites. Third-party reference material is available, although they could have done a bit more in terms of breadth and depth. Feedback on content was also taken quite seriously: after its initial run, the course was modified to reflect student input and address some frustration. One unit of the course proved to be too much of a leap for many students, and based on this feedback, Udacity and Evans updated the syllabus and added a whole series of lectures attempting to fill in this gap. One final note that echoes some other reviews I read: the course title is a bit misleading. It would be better to call it An introduction to programming with Python; large swaths of introductory core computer science content were barely covered or just ignored (e.g., general language-independent concepts, algorithms).
  2. Pedagogy: Evans is a good, experienced teacher, and it came through loud and clear in this course. He followed a logical and linear progression, with each concept building on what had been taught previously. The variation in the way content was presented also helped avoid the "sage on the stage" problem. The course wasn’t just a series of video lectures, which made for a more engaging experience.
  3. User Experience: While I found the overall Udacity user experience to be decent, there were many things that were poorly executed and frustrating, despite apparent design modifications that had been made based on user feedback. A few of my complaints:
    • The course is broken into units, and each unit is broken down into a series of bite-sized lectures and quizzes. There was no indication, however, of the total duration of videos in each unit, nor was there a detailed breakdown of what was covered in each lecture. This made it difficult to skip around, jumping over material I already understood. It also made it unclear what kind of time commitment was involved in each unit.
    • Reference content is not easily accessible in context; it’s often attached to individual lectures, then disappears. Some, but not all, of this content can be found in the course Wiki, but the UI did not make this clear (i.e., the Wiki was fairly hidden).
    • It’s not possible to just skip to the solution for a quiz. If you don’t want to do a quiz, you have to first submit some kind of answer, after which you can move on.
    • Overall navigation and wayfinding within the course could be improved significantly.
    • It’s impossible to search for course content, given that it’s all embedded in videos that are not tagged. This shortcoming is likely common for most courses with video-only content.
  4. Connectivity and human interaction: Udacity relies on discussion forums for interaction. While I did not participate in these myself, they appeared quite vibrant and helpful for students who were stuck. Others have complained that these forums can suffer from know-it-all students who make others feel dumb, but this is true of any online forum: there will always be trolls and obnoxious people, and it’s up to the community to police them. Beyond the forums, Udacity has a course Wiki, which seems both dead and not nearly as useful as it could be.
  5. Tie-ins to real-world problems: One of the great things about CS101 is that the entire course is couched in a real-world problem: how to build a search engine. This Rosetta Stone helped anchor the course content, quizzes and homework; everything was aimed at achieving that objective, which I found useful. Computer science concepts can be very abstract, and it helps to tie them into something with which everyone at least has familiarity (i.e., we’ve all used Google and get the basic idea).
  6. Technical support: All CS101 content is executed in the context of a browser, which means very little tech support is required (e.g., people don’t have to install software to do the course). As a result, I can’t really assess the course on support availability.
  7. Feedback and response: Feedback on Udacity courses can be submitted at the end of each unit. Students can also provide comments and feedback in the discussion forums. By all appearances, Udacity and Evans took feedback to heart, given that they produced an entirely new set of course content to address shortcomings. Big kudos for this level of responsiveness.
  8. Assessment: The course falls down a bit when it comes to assessment, though this is partially due to limitations of the technology platform. They are clearly not pursuing mastery-based learning, given that the quiz system can easily be gamed; you can proceed without having demonstrated understanding. Presumably, gaming is not as easy for the homeworks, though there is no way for them to verify that you did the homework yourself. In cases where students do submit actual work, the outcome is binary: you get it right or wrong, with little or no further indication about where errors were made and how to improve. This problem is endemic to brain-dead robot graders, and is a major challenge for MOOCs as a whole.

As a final note, CS101 gets glowing praise on both Knollop and coursetalk, though the number of reviewers is quite limited. A few other reviews provided more in-depth analysis, and were generally very positive as well (see for example The Good MOOC, Eternally Neurotic, and Casting Out Nines).

Next up

In the next installment of this series, I’ll review Udacity’s Web Development course (CS253), and then wrap things up with some final thoughts on the future of MOOCs.

  • I’m taking the course currently. So, how much confident do you feel after taking the CS101? Can you make web crawlers and do further advanced projects? What was your Journey after the MOOC?