by ·0 Comments

Normally through the summer, I like to do a (fairly large) bunch of MOOCs.  I do this to keep my study habits sharp, and learn lots of new things … Or re-learn old things, as I’ve re-done MOOCs to cement my knowledge before.

This summer, I don’t think I can be bothered.  One issue is that I think I fairly well burned myself out with revising for the MST124 exam.  As great as it felt to put that exam in its place, I was still academically exhausted after.  Another issue is that there just aren’t any good MOOCs right now.

Which I’m sure isn’t true.  There aren’t any that I’m interested in that are high quality.  What I should really be doing, right now, is studying for a Cisco CCENT or CCNA.  And I tried.  But I tried using a Udemy “MOOC”.  I’m not going to name and shame the specific one I tried (I actually tried multiple, but one stands out), because I think the entire Udemy business model is flawed and engenders worthless courses that aren’t fit for purpose.  It was basically as though some guy wrote some notes from an actual MOOC, turned them into a PowerPoint presentation, and video taped himself reading it.  It’s completely worthless as a way to assimilate knowledge.  The others, whilst providing additional materials, were essentially the same.  Their pedagogical value was very close to nil.

Let’s put it this way: I now have more respect for Microsoft training.  Which is still pretty close to zero, but it’s a tiny bit less close to zero than it was two months ago.  I’ll probably end up taking TM257 and TM357 now, though.

The flip-side to taking it easy is that I’m going stir crazy.  My brain’s dying to learn, so it’s occupying itself with other things in the mean time.  I wanted to improve my handwriting and writing speed as both of my exams next June will be written exams.  What started as a perfectly logical plan of action quickly devolved into me becoming completely obsessed with fountain pens.  (Though common here in the UK amongst school children when I was going through the system, I never touched one in the States until I’d grown up, and then tried a defective one that put me off trying another for decades.)

Don’t get me wrong, I’m quite happy in my obsession, especially as I know it will die down and disappear soon (like all of my obsessions) but it’s not exactly productive.

Anyway, I’m going to give a few eBooks a go for preparation for M250 and TM254, but mostly … I’m taking the summer off, academically speaking.

by ·2 Comments

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 mooc.fi 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.

by ·4 Comments

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.)

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 ·4 Comments

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.

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.

by ·0 Comments

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.

by ·0 Comments

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.

by ·0 Comments

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.