Course Title: 6.00.1x Introduction to Computer Science and Programming Using Python
Provider: MIT via edX
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.