These last two Stage 1 modules couldn’t be more different.  TM129 was far too easy for 30 credits, was a waste of both time and money, and makes the OU look a bit like a fake university for even offering it.  The tutor support on the module was amazing.  MST124, on the other hand, while being far too time-consuming for a 30 credit module, was a wealth of information, well structured learning, and left me with the single largest academic confidence boost I could imagine.  The word to paint my tutor in the best possible light would be “terrible”, though.

TM129 was born as three separate 10-unit modules.  My guess was that, much like now, students were forced to take all three modules, with no alternatives, so eventually bundled them up and called them a single module.  There’s not much to really tie them together, however.  The first block in the module, Robotics, doesn’t see students building a robot.  Or designing one.  Or touching one.  Or controlling one.  Or learning how to build or design one.  Students do learn how to control one, by using a (barely) modified programming environment for controlling Lego robots.  The amount of programming done is significantly less than in TU100, and probably less than in TM111 and/or TM112, making that bit of the module superfluous.  Understanding actuators, sensors, different high-level models for robot behaviour, and what can only be described as robotic ethics and sociology round out the block.

I’ll be honest, I enjoyed the robotics block.  Most students I spoke to did not.  I was interested enough in the topics covered to start playing around with Arduino processors, and have made some pretty fun little projects since then.

The second block is on networking.  For this, they just give students a Microsoft networking essentials book, and tell them to read most of it.  And that’s the block.  A £30 book which is pretty darned out of date.  On the one hand, it’s not useless information.  It’s a good primer for networking.  On the other hand … It’s a £30 book!

The third block is on Linux.  Several students found it difficult to complete the module because the tools referenced in the module were so far out of date.  It was very, very light on actual information, again.  I didn’t really hate it outright, because I found plenty of tips for every day Linux use.  But as a primer for somebody who doesn’t know Linux, it was insufficient.  For anybody familiar with Linux, it’s unnecessary.  So it’s a block without an audience, really.

Most horribly in relation to all three blocks, the assessments (TMAs and EMA) had essentially nothing to do with the Learning Objectives.  One task asked students to evaluate a server and client needs to recommend a Linux deployment running several different servers, how to install them, how to test them, and complete it in 400 words.  The problem with this is that only installation and testing were mentioned in the module.  Evaluating client needs and researching server software weren’t part of the learning objectives at all.  Neither were questions on Intellectual Property law, and a host of other questions in the other blocks.  It’s like the module team didn’t even read what they’d written, they just came up with some questions that sounded related to the block titles.

Though I enjoyed the blocks (and, perhaps surprisingly, I really did), I have to say that I feel objectively that the module is not fit for purpose and should be boiled in tar.

MST124, on the other hand, was nothing short of amazing.  I started preparing for MST124 literally over a year ago.  By the time October rolled around, I felt like I barely knew enough to get started.  Indeed, I was still making silly mistakes left and right when I started, because I was so far out of practice.

It was an absolute slog of a module.  It would often take me significantly more than 20 hours a week, when the recommendation for a 30-credit module is about 8.  Most of Unit 3 (functions) and Unit 11 (Taylor polynomials) are written very, very poorly, and I recommend anybody studying MST124 find outside reference material to help with them.  Activity 17 in unit 7 will possibly remain in my memory forever as the most horrifically impossible task, until I again sought outside help understanding it.  But other than these rough spots, it was a steady, continuous climb.

I felt like I’d learned everything well enough by the time I completed the routine unit study, but I wasn’t testing well at all.  So I really, really threw myself into revision.  I revised more every week than I’d spent studying.  It would have been six solid weeks, but I was extremely ill for the better part of one week.  (ALWAYS stay one or two weeks ahead of the module planner to cope with unexpected emergencies.)  When it all paid off in time for the exam, I felt completely unstoppable.  I’d gone from struggling with basic trigonometry and never having dealt with logarithms at all to nearly acing an exam which covered topics most people will never learn.

So if my tutor was rubbish, it’s alright.  The materials were brilliant enough without the help.  (Although it was nice to be part of the Facebook group.  Don’t know how far I would have gotten without them.)

So that’s it.  Two completely different modules.  The OU could really learn a lot by having all of the module teams take MST124 and see how amazing it can be done.

Course Title: Object Oriented Programming with Java, parts I & II
Provider: University of Helisinki
Price: Free
Level: Beginner
Effort: 2 modules, 6 weeks each (by ECTS reckoning, as many as 300 hours)
Prerequisites: None
Completion awards: Free certificates of completion for each module

About the course:
In short: highly recommended.

This is not a computer science course, but it doesn’t claim it is.  It really is two (nearly) completely different courses.  The first one is about learning Java syntax and semantics, and the second one is about object-oriented programming in general, and some intermediate Java-specific techniques, as well.

It’s also not a MOOC, making their URL ironic.  It’s online, and it’s open, and a lot of people take it, but it’s not Massive Open Online.  It is an online textbook, and a very cleverly written code testing system.  You’re on your own.  Allegedly there’s someone to answer your questions in a few hours on IRC, but IRC users won’t really need the help, and answers to emails might take a few days, but again, you’ll almost certainly be past that “week” by the time you get an answer.  There’s no online community, no forums, no helping each other.  It’s an online textbook, an IDE, and nothing else.

(As there’s no video of anybody reading the book or walking your through its examples, it strongly parallels Open University modules without the support.  If you’re looking for the perfect module to taste what online study is like, this is it.  Imagine this course, but eight months long instead of a few weeks.)

Part I is a tutorial for basic Java usage, and is brilliant.  It’s quick, it’s informative, it’s very accessible.  It took me a week in my spare time, and was blown away at how quickly I picked up the skills with how they were taught.

Part II has a massive jump in difficulty, especially the week-ending challenges, where you’re welcome to use any programming techniques you care to in order to solve the problem, so long as its behaviour is exactly correct.  It highlights what I really love about programming:  There’s only ever one right answer, but there are countless ways to get there.

Being presented by the University of Helsinki, it’s an English course, and the vast majority of the content is very well written.  There are some peculiarities of language, however.  For example, the course keeps referring to built-in classes as made-up classes, which is … pretty much the antithesis of built-in.  So there are a very few minor confusions.

The certificates you get at the end are very clear about what has been studied, and even states that had it been accompanied by the university’s overseen exams, each would be worth 5 ECTS.  For the 10 credits between them, that’s 20 OU credits, and a little less than TM111 or TM112.  I’m guessing it’s not quite that impressive, but it does highlight that it’s the exact course their students take, and it’s definitely fit for purpose.

I’d like to thank Newbie from a comments page for pointing me in the direction of these modules.  They’re everything the Microsoft course wasn’t.  It’s not perfect.  It doesn’t include recursion, doesn’t discuss why one method is preferable to another, and states that abstraction is very important, but doesn’t teach any actual techniques for it.  Still, it’s a coding course, not a computer science one.

A highlight for me was using both NetBeans and IntelliJ IDEA to write the code and interface it with their testing system.  It’s a slick system, and couldn’t really be better.  It’s by far the best automated evaluation I’ve ever seen of checking code, including the one from CS50.  (Also, I enjoy both NetBeans and IntelliJ, and their ability to both prompt and automate things, but found myself working about twice as fast in IntelliJ.  If you have a student email address, do yourself a favour and get a free license for the full version.  If you don’t, at least check ot the community version.)

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.

Course Title: Learn to Program in Java (DEV276x)
Provider: Micosoft via edX
Price: Free
Level: Introductory
Effort: 6 — 10 hours per week, 4 weeks, allegedly self-paced
Prerequisites: None
Completion awards: Verified Certificate available for USD$99
tl;dr: Take the University of Helsinki Java courses, instead

About the course:

No.  Just no.  Don’t even think about taking this course.  Run away.  Invent your own rules for how you think Java might work, and use those instead, because they’re sure to be more useful than this course.

I apparently signed up for this module on the day it opened, but I’m not really sure how that happened.  Anyway, the discussion forums were filled with people enthusiastic about what they were there to do.

There was no syllabus stating what the structure of the course was.  There was no course news, no updates, no welcoming letter, nothing telling you what to click on first.  The first week’s instructions, however, made it clear that the IntelliJ IDEA was an absolute necessity for the course.  (It’s not.  Feel free to use whatever IDE you enjoy.  They do at one point discuss how to set up a new project in IntelliJ, but they skip most of the difficult steps, and get another step wrong.  I learned much more about Java following the IntelliJ instructions for setting up a new project than I did in the first two weeks of the Microsoft course.)

After a few days, several of the students had finished the first week, and even though the course description said it was self-paced, there was no second week.  Some people asked in the discussion forums when the content would become available.  Other students were asking for help on things.  Some for clarification.  There was no response from anybody associated with the course’s presentation.  They had hit a button to upload a third of the course, and run away.

One step up in seriousness was that response was necessary, because much of the documentation is wrong.  Some of it over-simplifies things by saying this-or-that doesn’t exist, when it does, or you can’t do this-or-that, when you can.  Other times, the script-reader’s information is just incorrect, and other times the questions they quiz with have 0 correct answers from which to choose.

Another step up in seriousness is that the course is completely uneven.  The script-reader reads a mind-numbingly patronising script which insults the students’ intelligence.  Then the documentation and quiz questions expect the students to have a much higher degree of understanding than what was just discussed.  (Some courses claim this is a feature encouraging outside study, but this is a different beast entirely.)  Many times, there’s no indication of a correct answer in the script or the documentation, and it can’t be learned practically by experimentation.

I refer to the “instructor” as a script reader, because that’s what she’s doing.  I have no doubt that she does understand the subject content, but she’s just reading a script, and not teaching.  Worse, it’s clear that she didn’t write the script, because she often stumbles when something is wrong, not being clear enough, or she’s simply struggling with it not being the right way to present something, but she just ploughs on through it regardless.  One (patronising) committee wrote the script, a different person read it, a different team wrote the documentation, and someone else wrote the questions, and clearly none of these people ever met each other.

There were at least two questions which showed that the person who wrote the questions had no idea how iterative loops worked.  One had a question with zero right answers, and another with two right answers.  And, of course, there’s no way to get them fixed, because nobody from the presentation is there.

Anyway, when the second week was finally released, randomly nine or ten days after the course opened, and there was still nobody to answer questions, and the documentation was worse than ever, I finally just bailed.

To sum up: No.

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.

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.

I’ve done a lot of MOOCs in the last few weeks.  The vast majority of them rate “Meh” on the scale from “Ack!” to “HOLYCANIBITZ!”  At the two extremes, I feel like I should say a bit more about them, but here are a bunch of the Meh courses that are so forgettable that I don’t have much to comment on.

Course Title: English: Skills for Learning
Provider: The Open University via OpenLearn
Price: Free
Level: Introductory
Effort: Self-paced, 24 hours, estimated 8 weeks
Prerequisites: None
Completion awards: Statement of Participation, Open Badge

About the course:
This was a fair mix of instruction and practical exercises.  The information in this course is a very small subset of the information in The Good Study Guide, which I’ve previously mentioned.  The actual time on the course for me (taking the practical exercises very seriously) was about 6 hours.  If I didn’t have the Good Study Guide, it may have been a nice reference before beginning higher education.

 

Course title: Information Security
Provider: The Open University via OpenLearn
Price: Free
Level: Advanced
Effort: Self-paced, 10 hours
Prerequisites: None
Completion awards: Statement of Participation

About the course:
This course is listed as an advanced course, but I can’t for the life of me figure out how. Really, this could have been a much shorter MOOC than its realistic 90 minutes (most of which was spent choosing and listening to a podcast): CIA stands for Confidentiality, Integrity, and Accessibility, and listen to information security podcasts.  Job done.

 

Course Title: Good Brain, Bad Brain: Basics
Provider: University of Birmingham via FutureLearn
Price: Free
Level: Introductory
Effort: 9 hours over 3 weeks, commencing on set date
Prerequisites: None
Completion awards: Certificate of Achievement + Transcript (£59 + shipping) for completing 90% of course content, attempting all tests, with score of 70%, or Statement of Participation (£39 + shipping) for completing 50% of course content and attempting all tests

About the course:
Well, as the title of the course implies, this is very basic.  But it’s also very good.  It’s a concise and informative description of many of the functions and attributes of the brain.  And while very interesting, I don’t think my heart would be in it to complete the three-part series this course is a part of.  Also, I don’t think I could take it listening to those pronunciations and reading those spelling choices again.  It felt like every scientific word was deliberately pronounced wrong and spelled the least usual way.

 

Course Title: Introduction to Cyber Security
Provider: The Open University via FutureLearn
Price: Free
Level: Introductory
Effort: 24 hours over 8 weeks, commencing on set date
Prerequisites: None
Completion awards: Statement of Participation (£34 + shipping) for completing 50% of course content and attempting all tests

About the course:
This seems like it would be a good course for someone to start considering cyber-security. As these concepts are a part of my job, none of the information in it was new, and I completed the 8 week course in about three days, so maybe 10 hours or so. I like that this course doesn’t shy away from technical descriptions of digital encryption techniques, though it doesn’t describe any actual computational mechanism for any of the concepts. As it was most definitely not directed at me, I can only say that it seems good, and has all the points and more of the things I’d want to teach someone for a primer on the subject.

It needs to re-think its active learning portions, though.  Though this is an introductory course and is limited to digital information rather than general information, it’s far more useful to all learners than the “advanced” course on OpenLearn above.

Course Title: Learn to Code for Data Analysis
Provider: The Open University via FutureLearn
Price: Free
Level: Introductory
Effort: 12 to 20 hours over 4 weeks, commencing on set date
Prerequisites: None
Completion awards: Statement of Participation (£19 + shipping) for completing 50% of course content

About the course:

I wanted to get my feet wet with some structured programming instruction, since I’m entirely self-taught up to now. (Well, not entirely. There was that half semester in Mr. Barton’s Pascal class where I tried to hack into the school network instead of listening to him drone on about methods of averaging.)  I also wanted to start learning Python.  This course seemed like a good fit.

Data Science or coding for Data Analysis is all the rage in MOOCs right now.  I found courses all over the place teaching essentially the same skills with various programming languages. Or one from Microsoft still insisting that Excel was up to the task.

This course only touches on the barest beginning concepts in coding.  It uses pre-defined contexts for Object-Oriented Programming, but doesn’t really describe how they work aside from feeding you the formula, “If you type what I type, you’ll get the answer I get.”  The syntax it teaches is almost exclusive to the problem domain of data analysis, and it doesn’t teach much outside that syntax.

One nice thing about the course is that it’s tough. It’s not one of those courses that says it takes 4 weeks, but is actually over in about four hours.  The first two weeks took me two or three hours a piece.  The third week took me nearly five hours.  The last week was well in excess of five hours, and could possibly have been ten.  It was an absolute slog, but it was very informative.  Again, though, mostly in the realm of data science.

The course information page says that the effort required is 3 hours per week, but once you join the course it says 5 hours per week.  So keep your eyes open if you’re intending to take it.

It’s not horribly helpful on its own.  It does teach about Python, and gave me enough familiarity with it to decide that I’m not a fan of many of its shortcomings. If you do need to learn coding for data analysis, this course won’t be enough to be helpful.  If you need to learn coding for reasons other than data analysis, this course won’t be enough to be helpful.  So it’s just a taster of Python in this specific context.

One odd thing of note was that there was a great number of facilitators on the course from the Open University to assist students, but they weren’t the most polite. They were a bit aggressive with any student suggesting something would be easier a different way, or that there was a shortcoming in either method or resource.  But they were helpful to those on the course, and there were a lot of them, more support than I’ve ever seen on a MOOC.

A few weeks ago when I reviewed OpenLearn’s Succeed With Maths MOOCs, I said that there was a much better option out there.

Course Title: Various, depending on what you want to learn
Provider: Khan Academy
Price: Free
Level: Introductory, Intermediate, Advanced
Effort: Self-paced
Prerequisites: None
Completion awards: In-site badges

About the course:

Khan Academy says they’re not a MOOC.  They’re Massive in intake, Open in philosophy, Online by nature … So that just leaves Courses.  They say they’re not a MOOC since they don’t have structured, led courses with beginnings and ends.  But they do have courses.  In fact, they have several different flavours of courses.  They have subjects, missions, skills, and … well, some kind of skill grouping that isn’t explicitly defined.  It’s in the vein of a cMOOC, rather than an xMOOC.

You just drop in, and drop out, and study what you need to study.  I’m not sure if the instruction is really as fantastic as I think it is, or if it’s just presented in a way that my unique brain makeup interprets and absorbs well, but it’s fantastic for me.

In junior high school, I had a teacher who held me back from the next year’s advanced maths class, because while I’d performed well in exams, I didn’t do any of the coursework. Then in high school another teacher noticed that the rest of the class asked me to re-teach what he’d finished lecturing about every day.  His response was to force be back up into advanced maths the following year.  The result was that I skipped trigonometry entirely.

I’ve struggled through with trigonometric functions, having taught myself a few of the rules, and then using the basic blocks I knew to struggle through more advanced issues, by combining those blocks with each other or with basic algebra.  But I’ve always felt like there was a huge gap in my learning because of this, and I’ve been a little ashamed of my skills in mathematics because of that gap.  I had tried multiple books over the years to fill that gap, but didn’t really feel like it got me anywhere.

Khan Academy filled that gap within 12 days.  In fact, what it did is show me in elegant, logical steps that were effortless to take in, that I’d gotten it right all along.  But now I don’t have to re-work and re-invent trigonometry each time I tackle it; they’ve made the knowledge much more accessible to me.

My five-year-old son was very excited to watch my progress, and see the badges I was getting, and how my avatar was growing.  He asked me to set him up an account, too.  I did, thinking he’d just log on, have a look, and log off.  Joke’s on me.

He goes on for about an hour a day, just to play.  By play, I mean take quizzes, work through practice questions, watch videos on new maths concepts … An hour a day.  And what has he learned?

He started out doing addition within the 1-20 range, and subtracting numbers in the 1-10 range.  He has now mastered two-digit addition and subtraction, is working on three-digit, can read an analog clock with or without numbers, can read information from bar graphs and solve story problems using two bar graphs, is better at understanding the operand required from story problems than I am, and is starting on geometric principles meant for 7 to 9 year olds.  In eight days.

He advanced so much, that his school literally started sending home worksheets for the next year’s maths.  Which is something that they said at the beginning of the year that they would not do under any circumstances.  (We had called for a meeting with his teacher and the head of English Learning for his school to discuss advanced reading for him, and it was stated then that their maths curriculum was designed in such a way that they would never allow students to use maths resources from advanced years. Which upset us, but didn’t think would become an actual issue.)

In addition to maths, you can study programming, history, music, economics … A lot of things. It is an amazing self-education tool and well worth any time invested in it.