Course Title: Software Construction: Data Abstraction
Provider: University of British Colombia via edX
Price: Free
Level: Introductory
Effort: 8-10 hours per week, 6 weeks
Prerequisites: How to Code series or Systematic Program Design series (same tuition)
Completion awards: Verified Certificate for $125 as part of their Software Development MicroMasters course of 6 similarly price modules

About the course:
I had amazingly high hopes for this course.  In fact, it’s difficult to judge it fairly because of how high my expectations were, which caused the very wide gulf to reality.  I’ll do my best to judge it on its own merits, but can’t help comparing it against UBCx’s stellar How To Code / Systematic Program Design course linked above.

As I started taking the course, I became ever more sceptical (skeptical for the yanks) of the the entire philosophy of the course.  It doesn’t start with theory, and it doesn’t start with academic information.  It starts with what is claimed to be a practical approach, much like learning a spoken language through immersion.  Except that while immersion is necessary for actual fluency, the best foundations of learning that language generally comes first from an academic study of it before the practical use of it.  Had I not just barely completed the Object Oriented programming with Java course, I would have felt frustration beyond measure.  They never teach enough to do useful things, and often only teach the bare minimum to answer a question after they’ve marked a quiz about it.

Beyond the approach, the technique they teach is … Well, it works.  It’s fair.  But students are expected to accept it as a religion, rather than as an education.  Edicts are handed down from on high, and we’re meant to accept them as though a flaming shrub had demanded them.  We’re not walked through the process of why.  We’re not lead to creating these tools in a meaningful way that they can be internalised and remembered, truly becoming a useful addition to our bag of tricks.  We’re just generally warned, “You must use these techniques … Or else!”  I lost count of how many times I quoted Sir Didymous saying, “Well, if that is how it is done …”

The point of this course is a tests-first abstract design of programs.  Define your program as a series of responsibilities, and devise tests for them, then code to your tests.  In my doubt, I had thought that it didn’t really unleash the power of object oriented programming.  And I was right, it didn’t.  But what it did was even more powerful: It allowed you to bring any tools you wanted to the party to get the job done.

Near the end of the course, I doubled back to an earlier project.  I had used the recommended methods to solve a problem, and they were ridiculous methods that utterly discounted both Java’s power in specific and object oriented programming in general.  I wanted to fix that, and re-wrote nearly all the methods.  But I stayed true to the precepts of the course as I did it.  And what I found was amazing.  I’d already done all the hard work.  I changed nearly EVERY LINE of actual implementation, but nothing more.  I didn’t even have to change the tests!  It took twenty minutes to rewrite eight classes, and then not only was it done, but it was tested, and I was completely confident in it.

So the course teaches good things.  It teaches powerful things.  The lecturer is easy to understand and isn’t boring.  But the things it teaches aren’t very complex, and could be boiled down to a thirty minute lecture, and that lecture would still involve the students more in understanding the reasons and therefore making it more absorbable and useful.

If you’ve got 30 to 50 hours to kill, give it a look.  But don’t reschedule anything, it’s just not that vital.  And definitely learn Java first.

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.

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.

While the TU100 module doesn’t actually start for nearly three weeks, I’ve gotten a fair head-start on it, so that I could learn more about how I’m currently learning.  The Good Study Guide hits the concept of self-evaluation quite hard, and I agree with it.  Six years is a long time, there’s an enormous amount of work ahead, and I want to give myself the best possible chance.

One problem I have with this is that once I start, I’m finding it difficult to put down.  First of all, it’s fun. I really enjoy this limbo of structured independent study.  Second, I’m desirous to prove to myself that I can make this a habit, and stick with it.  I find myself making excuses so that I start working as soon as the children go to bed so that it becomes second nature to me. (For example, last night I spent ALL my down-time in the kitchen, but with the door open so I could still share snarky comments about the TV with my wife, and didn’t even realise I hadn’t had any relaxation time.)  So the end result is that I’m a good deal further ahead than I’d really wanted to be.

I’d finished Block 1, Part 1 (‘Parts’ seem intended to basically take a week) after a few days.  I’m now in the middle of Part 2, but have also already completed my first TMA.  So that people understand what I mean when I say ‘finished’ a part or session, I thought maybe I’d describe some of the techniques I’m putting into effect so far.

I have difficulty concentrating while reading text, and I don’t think I’m alone there.  I can read the same passage of text about a dozen times without concentrating well enough to absorb any meaning, or even remember what I’d just read.  The most useful active learning technique that I’ve found to counter this is taking notes while reading.  Basically, it just makes sure that my brain engages in comprehension at every thought along my reading.

I use a 10″ tablet to flip open to my reading material (so far in e-books), then go online with my laptop to fire up OneNote Online to take notes in the cloud.  My notes then progress paragraph-by-paragraph, because I often find that doing so retains the clustered ideas found in each paragraph, and linking from paragraph to paragraph serially helps the flow of my notes.  (I said this much more succinctly in my TMA, and may be back to edit this section after the TMAs are marked, but I’m leaving my exact words out in case someone else subconsciously uses similar wording on their TMA and it triggers the OU’s anti-collusion software.)  I then write out a simplified bullet-point outline of the text.  So by the time I get done with a section of reading, I’ve re-written that section with a handful of words.

Then when I need to revise, I can read just my notes, which bring up the memories I associated when taking the notes, and I retrieve the entire meaning in a fraction of the time.  So how much writing am I doing, and how much time am I saving during revision?  Good question.  Let me check my numbers.

TU100 My Digital Life Block 1 Part 1 is roughly 14,000 words long.  Reading all of that and taking notes on it took approximately 6 hours (including activities), and condensed it down to roughly 3000 words (not including activities).  3000 words may seem like a lot, but I can barely keep birthday cards down to 3000 words.  (Imagine how I feel when a TMA says I have 200 words to say something!)

But that’s an excellent example that I have to do better.  I’ve cut down what I’m reading a lot, but 1 in 5 words still leaves a loooot of words behind.  On the other hand, it doesn’t take me much time to type the words, and the result is that I can recall them and their meaning very easily.  It might take MORE time to try increasing brevity beyond what I’m already doing.  If retyping every word would help me learn the information better (which, it won’t) I’d probably do it.

On a completely separate note, I’m also concurrently doing the MIT Introduction to Computer Science & Programming Using Python course on edX.  I really want to complete the entire course, but worried that I wouldn’t have enough time for both that course and my actual university course.  But it seems I needn’t have worried.  The MIT course takes about a night of my time a week, and the TU100 stuff (so far) takes about 4.  But we’ll see, as they’re both likely to ramp up.  As it stands, though, I could stop working on TU100 entirely until a week and a half before the end of the MIT course before I had to do any more work.

Course Title: CS002x Programming in Scratch
Provider: Harvey Mudd College via edX
Price: Free
Level: Introductory (suited to children)
Effort: 6 hours per week for 6 weeks, commencing on a set date
Prerequisites: None
Completion awards: Verified Certificate for USD$49

About the course:
This is not at all a bad course.  It’s well-suited to children, or really just about any ability level.  The children do need to be able to understand a fair amount of logic.  It’s a bit much for my 6-year-old son, even though he enjoys using Scratch.  (His ability level is simply knowing that command blocks are instructions for sprites, and lists of command blocks can be strung together.)

The course is described as a computer science course, but I really can’t feel like that’s justified. It’s a tour of Scratch’s capabilities, but doesn’t often describe theory or reasons for much.  There is an excellent amount of work with iteration, however.  One brief section also compares Scratch to industry standard programming languages, to show how the learning can be applied outside the Scratch environment.

Aside from it using Scratch, there was no prior indication that it was aimed at children, which it really is.  As Open University’s TU100 uses Sense, an off-shoot of pre-1.4 Scratch, there’s no reason to believe that a computer science course which uses Scratch must be a de facto children’s course.  There were plenty of students across many abilities and ages, so the discussion forums were a bit uneven at best.

The tour of Scratch begins with Scratch as the idealogical descendant of Logo incorporating a turtle graphics system.  This was bizarrely effective, because I was able to recall line-for-line programmes I wrote in Logo back in 1986 or ’87 after two weeks of lessons during elementary maths.  I reproduced it with just the addition of colour.

It winds past variables, iteration (as mentioned above), input, sprite-interaction, if-then-else logic, more iteration, functions, external calls, and even implies recursion with sprite clones.  Okay, for me, it took about 10 or 11 hours to get through everything but the final project, but that’s quite a list, and I can easily see it taking a young student a few weeks to get through that all.  But they will get through it all.  It’s all very logically laid out, it’s interesting, fun, and cool to keep them engaged, there are always lots of examples, and the progress made is a great confidence builder.

One confusing aspect is that the course has been adapted from some other curriculum, so it occasionally refers to weeks or other structures not present in the online, self-paced course.  It’s easy enough to ignore, but raises questions of how thoroughly prepared it is.

Two questions you might have for me are why did I take it, and what did I learn.

As stated, TU100 at the Open University, my first degree course module, uses Sense, which is based on Scratch.  Though I’ve played with Scratch before, and been impressed by it, I haven’t done anything in depth with it.  I was unaware of its true capabilities.  In a way, it’s a bit of a tragedy that I did that.

Scratch 1.6 is amazing.  It has functions, clones, lists, recursion … It’s great.  Sense, based on 1.4 or before, does not have clones, has no in-built stack for handling recursion data, and has to use calls for functions.  It appears as though it does have lists, in a custom solution.  I haven’t used it yet, so I’m still not sure.  I’m just lamenting that if I want to do recursion, I’ll have to use those lists to build my own stack.  Every. Single. Time.

And what did I learn?  Plenty!  One of my favourite moments was when I was polishing up my final project, and I wanted a custom score counter.  I searched the Internet for a Scratch solution, but couldn’t find anything that worked the way I wanted.  The closest I found was one which had a pre-set number of digits, with a separate sprite for each digit.  I realised that I could use recursion to call new clones of a single sprite to dynamically create as many digits as I wanted.

Another great moment is when I wanted to re-write a Rock-Paper-Scissors demo to include Rock-Paper-Scissors-Lizard-Spock.  The course wanted an If statement for each of the possible outcomes.  With Rock-Paper-Scissors, that’s just 6 possibilities.  With Spock and Lizard in the mix, it goes up to 15, and that’s already annoying.  So I diagrammed out the possibilities, saw a pattern, applied some modal maths, and realised there were really only three possible outcomes after said application.

So here are a couple of the things I created.  You can look inside any of the programmes to see how I did them, keeping in mind that I was learning as I went, so it’s not always the most logical way in the simpler programmes.

Jet Bike Steve: You Win Some, You Jetsam (Final project) WASD or arrow keys, up, W, or space to fire. 10 points per second survived, 10 points per star shot or collected, 25 points per bomb shot, and 50 points per guided-missile shot.

Derpa Deadfish (a game for my oldest boy)  You can go down, right, or left, but can only float up. Collect worms, avoid sharks (or turn them off), and use the safe-zone pad at the bottom.

Course Title: How to Code – Systematic Program Design
Provider: University of British Colombia via edX
Price: Free
Level: Introductory
Effort: 5 hours per week, 5 weeks per course, 3 courses – about 75 hours
Prerequisites: None
Completion awards: Verified Certificate for each of the three courses (USD$49 or $50, depending on which link you click on), automatically awarded XSeries Certificate if all three Verified Certificates are awarded

About the course:
Go.  Sign up now.  I don’t care if you hate computers or have been programming professionally for years.  This is an amazing series and getting through the course is highly rewarding.

There’s a lot to say about this series.  For one thing, the level of effort required is very real.  It took me three or four weeks to get through all three courses, and I was staying up late for hours on end.  And I’m considering working through it all again so that I retain it longer.

Beyond that, let’s start with the concept.  The SPD course introduces the idea of designing a computer programme as an abstraction layer between the solution and the coding.  It’s a tool for producing a template for a solution which is orthogonal to the language being used.  And it’s genius.

SPD takes this method from the How To Design Programs book, by Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi.  It focuses on data-driven programme design, which was a new concept for me.  You define data, which informs what can be done with it, which influences function design, and so on.  By the end of the course, there were still experienced code-jockeys decrying the lack of well-named variables, without realising that when you’ve clearly defined your data and what it can and can not represent, it’s irrelevant. You can’t possibly be confused what “variable c” means when you’ve stated that the only valid data type for variable c is degrees Celsius.  If you’re an old hand at programming and haven’t used data-driven programme design before, it’s worth a look to evaluate why you do things the way you do them.

It uses its own beginner language that isn’t outrageously useful outside educational context.  It is Turing complete, but it’s a bit of a pain to use in real situations.  Its environment is also quite slow.  The reasons for not using a commercially viable language are discussed early on, and I wholeheartedly embrace those reasons.

By the end of the first course, you’re already designing your own programmes using the data-driven model. It was around this point that I realised the beauty of defining the data and describing functions based on it.  If data X has properties Y and Z, then I can write functions for X that read and/or modify Y and Z, either by itself, or in relation to other data.  It dove-tails beautifully with object-oriented programming, but the course doesn’t cover application of its high-level theories to low-level techniques with other languages.  (However, the ProgramByDesign project is also working on How to Design Classes which features at least a subset of Java.)

Professor Gregor Kiczales is one of the best technical instructors I’ve ever seen, and I used to do that professionally.  His focus is on getting the programme design right, so that the code can flow naturally from that design.

It is an amazing foundation for how to approach programming design.  Playing with Scratch, I didn’t imagine I could possibly apply the HtDP principles to such a strange and specific programming environment.  However, I ran into a few bumps so I broke out data definitions and templating, and solved the problems in minutes. (Note: Never underestimate the power of testing well-chosen and well-defined examples.)

Anyway.  Just sign up.  Sure, it’s 50 to 80 hours out of your life, but it re-introduces you to the digital world in a way which will undoubtedly increase your comfort with it.