by ·0 Comments

Course Title: CS50 Introduction to Computer Science
Provider: Harvard via edX
Price: Free
Level: Introductory
Effort: 10 – 20 hours per problem set, 9 problem sets and a final, self-paced
Prerequisites: None
Completion awards: Verified Certificate available for USD$90

About the course:
A lot of people view this course as the gold standard in introductory computer science MOOCs.  Having been through it now, I’m afraid I have to disagree.  It is an amazing course, though, and the one best placed to get you into the middle of useful coding as quickly as possible.

The structure of the course follows what you might expect of a university course translated to an online MOOC: each week has a very, very long lecture, followed by shorter bits from teaching assistants highlighting important concepts, and then there’s a problem set which is a series of challenges which ostensibly can be solved using the techniques introduced that week.  There is an exponential increase in difficulty from week to week, because both the material covered is more difficult, and the amount of documentation relating to solving the challenges is reduced.  This is meant to foster habits of independent study to resolve such challenges in the future.

This structure is the first relative weakness of the course.  (Relative to the MIT CS introduction course using Python.)  The MIT course imagines education looking more like the web.  The Harvard course spends countless resources trying to make the web ape its own institution.

As a former trainer, the most important thing about educating people is keeping them awake and interested long enough to learn, so it’s really about entertaining.  The lecturer, Professor David Malan, is extremely entertaining on stage.  The format is fundamentally outdated, however.  There could be a hundred clips where there’s currently a 105 minute video, each collated, indexed, and cross-referenced.  A build-your-own lecture series could take the place of an impending Sander’s Hall nap.  MIT did this beautifully in their latest foray into CS as a MOOC.

The languages “taught” are fantastic.  They start by giving a few rules-of-thumb in Scratch, and pretend that they’ve therefore taught it.  They next spend several weeks on C, and this is an impressive tutorial for the language … for any language.  They then give a small grounding in Python, and then a cheat sheet for SQL, JavaScript, and maybe a few others.  Really, I think they’d do better by having a hard limit on two languages, because everything beyond Python was literally worse than having no experience at all.  Students are expected to meaningfully interact with those other languages, without sufficient preparation.  In solving PSets, students already know those topics, or they luck into trying the correct technique the first time, or they end up chasing their own tails for hours and hours before giving up and asking on a public forum for help.  I spent many hours answering questions in the CS50 subreddit to alleviate some of the pain of such students.  (An example is that they expect students to use object-oriented programming techniques, but never discuss what an object is, let alone what object-oriented programming is.)

I would disagree that it is an introductory module.  It may be introductory if you’re on campus at Harvard, and can stop in and chat to a staff member for twenty minutes, and you’re literally spreading this across a third of a year.  If you’re doing this on your own, you’re going to have to come with a pretty strong intuition of why computer programs don’t do what you expect, and how to troubleshoot to figure out where it all went a bit wrong.  (The tool created to understand this in C is fantastic.  Because of this, they don’t teach how to figure out how to do it when learning C, and therefore students have no concept of basic troubleshooting techniques once the module moves away from C and that tool is no longer available.)

If you survive through to the victory lap of the final (which is really just whatever personal project you want to make a video for), you’ll be ready to take on any formal CS education.  I doubt you’ll be prepared for properly undertaking independent study, however, because the theory behind the coding is often ignored.

The real time I put into this was between 4 and 12 hours per PSet (typically on the lower side), so maybe 60 hours, plus another two hours each “week” watching lectures.

I’d recommend people interested in CS and coding take this module … but only if they also undertake the MIT or UBC introductory modules.

by ·1 Comment

When the University of British Columbia‘s edX group put up information about a new MicroMasters program for Software Development, I was excited.  (I get excited by not having to pick my son up from karate, or finding paninis in the canteen.  So keep in mind I have a low threshold for that word.)  Not because of the silly certification it could bestow for US$832.50 (currently about £650), but because I loved their Systematic Programming Design series I took last year, and was looking forward to new content.  The first course in the MicroMasters series is How to Code: Simple Data, and it started in April.  I wanted to finish up this year’s university stuff before tackling it, so I jumped over there sometime last week.

For good or ill, the first two courses in the MicroMasters program are just the original three courses in the SPD series.  In the SPD series, they broke the 11 weeks up over three courses, and now they’re breaking them up over 2.  There appears to be a benefit if you do pay the optional amount for the certificates, in that you get contact time in the form of Q&A sessions with the staff, so you can ask for assistance understanding whatever is personally confounding you, and you get your final project marked by staff, too, so you’re not just going off of your own potentially flawed understanding of the material when grading your own work.  (“Mark yourself out of 10.”  “A million thousand bazillion.”  “Fair enough.”)  I don’t know that it’s worth $125, but it’s not worth nothing.  (You could buy more than 100 tacos for that.  Now tell me it’s worth it.)

Anyway, they won’t move onto the new material until August, when they apply Data Abstraction to Java.  This is good not because I care one way or the other about Java (I get as uptight about people debating programming languages used in computer science as the people who are doing the debating), but because I can see how to apply their techniques to Object Oriented Programming … Though, to be honest, it’s much easier to see after studying what I have over the last year.  Systematic Program Design isn’t OOP specific, but it is beautifully closely related.

by ·0 Comments

Course Title: 6.00.1x Introduction to Computer Science and Programming Using Python
Provider: MIT via edX
Price: Free
Level: Introductory
Effort: 15 hours per week, 9 weeks (really 8 weeks and 1 day) — about 120 hours
Prerequisites: Basic algebra, aptitude for mathematics, prior coding experience helpful
Completion awards: Verified Certificate ($49) with at least 55% course marks, and 3 credits “Academic credit” through Charter Oak State College (65% course marks and $100 in addition to the verified certificate)

About the course:
This course is heavy on the “Introduction” and “programming using Python” portions of its title, and somewhat lighter on the “computer science” section, but it does a credible job of each.

It dovetails beautifully with the Systematic Program Design series I reviewed a few months back.  On one hand, this course gives object-oriented context to the basic principles in the SPD course, and provides a great roadmap of what’s next.  On the other, the SPD course fills in a lot of the data structure and raw theory gaps in the MITx intro course, as well as showing recursive design in a much more powerful light.  Taken together, they really feel like solid first steps into really understanding what’s going on under the hood, and how to direct the processes.

This edX course is an updated and platform-specific version of the MIT Open Courseware teachings on the same topic.  I flipped back and forth between the 2011 version and this one for at least half of the course, so some of the specifics I remember may actually be from the OCW course.  It’s difficult to choose a favourite lecturer between Profs. Grimson and Guttag; they both present the lectures with humour and clarity that’s easy to follow.  The bite-sized pieces of the edX course are generally better, but the poor “finger exercise” knowledge checks count against it.

To help students gauge their comprehension of the material, these finger exercises are interspersed between lecture segments.  Often, though, it seems like they’re just there to make busy work, as they’re not checking knowledge that’s useful, they’re just exercises that test nothing so much as your patience.  The worst of these are when they test concepts not in the lectures, which is defended by the TAs as inspiring independent study.  This excuse is somewhat undercut by the text on some finger exercises which states not to get too frustrated with a concept, as it’s explained in a later lecture.  If it’s explained later, then clearly that’s where we’re supposed to learn it, not through independent study, or they wouldn’t ever explain it.

There are so many concepts taught (well) through this course, I really can’t pull out a list.  In general, there’s a lot of coding principles, such as operators and operands, expressions, variables, calls, specific data structures, loops, recursion, conditionals, etc.  Discussion of address pointing supports lessons on mutability and cloning. Functions and objects, heirarchies.  There’s a fair bit to do with abstraction, though I feel this is handled better in SPD.  On the other hand, this course did a much better job of exploring algorithm complexity and costs.

Among the most useful (to me) portions of the course were the problem sets.  These were typically program problems you were let loose on to solve however you wish. Well, that’s how it was on the OCW version of the course.  In the edX version, which grades your programs and therefore has a very narrow interpretation of success, you mostly had to solve the problems how they wished.  It was really frustrating after the freedom of the OCW problem sets, especially when the same problem sets from one couldn’t be used on the other, and one case where the accepted solution technically required a different answer than what the problem description requested.

The required time for this course is way off.  First of all, this is not a self-paced course, and each “week” is released serially.  However, though it takes eight weeks before the content is all dished out, there’s really only six and a half weeks of content.  There’s a two week break between the third and fourth week releases, and the midterm exam is then inserted AFTER the fourth week begins, so it’s not to allow time for that.  Then the last week and a half are likewise empty of content, aside from the final exam.  (The final half week isn’t really useful, feels tacked on to advertise the next course, and falls well short of the OpenLearn data science introductions.)

The time you spend is then split three ways: Time watching the lectures and doing the exercises, time doing the problem sets, and time researching and revising.  If all the problem sets were written lucidly, I’d estimate about 10 hours per week, or about 65 hours.  Poor writing on the problem sets (similar to the above issues with poorly written finger exercises, but with an emphasis on the required solution differing from the requested solution) probably expand it to roughly 12 hours per week, or around 80 hours.  This is very close to the 50 to 80 hours of the SPD course, but I feel the SPD course is more informative of computer science, and less frustrating.

I think if I had it to do over, I’d do the OCW version instead of the edX version, just because it’s easier to evaluate my progress on my own than to have a computer do it.  Oh, the irony.