I just completed this class as part of my introduction to Scala. For those of
you that aren't familiar with Coursera, it is one of a growing number of organizations
that provide free online education, taught by professors from well-known universities. These organizations are part of a revolution in education, one
that might just change the way we think about post-secondary education. At present, they provide an excellent way to sharpen one's skills.
This was my first Coursera class, and I was impressed by its basic mechanics: the class website, lectures, and assignments. I'm not certain how much
of this is attributable to the Coursera team, and how much to Martin Odersky's grad students. I expect the automated grading tools to be the latter,
but the general website to be shared between classes. Unfortunately, it appears that you can't look at a class' content without signing up, so I'll
have to wait for my next class to make a comparison.
If you're thinking of taking an online class, I caution you not to underestimate the time commitment. This class was advertised as 5-7 hours a week,
which doesn't seem like much until you try to fit it into your schedule. I gave over a couple evenings a week for lectures, along with several hours
for assignments (usually before work, but occasionally on weekends). Since I got my undergraduate degree in a part-time program, taking two classes
a semester in addition a full-time job as a software developer, I didn't think I'd have trouble with the workload. I don't think my lifestyle has
changed much in the intervening dozen years, but it was tough to fit this class in.
On to the class. It was seven weeks long, with a couple of hours of lectures each week and a total of six programming assignments (some spanning
more than a week). Lectures were broken into segments of 10-30 minutes, focusing on a single topic. However, they weren't simply videos: each
lecture had one or more “quizzes” embedded within it, requiring viewer interaction and occasional typing. As a result, you'll need
access to the Internet; they aren't something that you can complete on a plane.*
Assignments are packaged as ZIP files containing skeleton source code and an Eclipse project configuration. They can also be built using the
sbt build tool, and you need to use this tool to submit them. The source code provides
stub methods for the expected implementation and a few minimal unit tests; you are expected to add more tests while completing the assignment.
When you submit an assignment, an automated grading tool runs a battery of unit tests and a style check (don't use short-circuit returns!).
If you fail any of the unit tests, you'll see the test output but not the test itself; sometimes it's a challenge to figure out what the grader
is trying to test.
If you've watched the MIT 6.001 lectures by
Abelson and Sussman (aka the SICP lectures), you'll find the Odersky lectures very similar, at least at the beginning (to the point of
using many of the same examples). Another point of similarity is that the lectures do not focus on the language itself. For Scheme, that's not so
bad: the language is simple. For Scala, you'll want to have an introductory book by your side (for example, Odersky's own
Programming in Scala). You'll also want to keep the
Scala Standard Library documentation open.
My chief complaint with the course is that it occasionally focused on functional programming to the detriment of good programming,
particularly in the assignments. For example, the assignment on Huffman coding used classes as mere data containers, moving all of the logic into
standalone functions. Within the context of the assignment — pattern matching — this approach makes sense. However, in the real world I
would want to see this implemented with runtime polymorphism: pattern matching in this example is just a glorified switch.**
That said, I highly recommend this class. If you haven't worked with a functional language in the past, you'll find the ideas new and (hopefully)
interesting. Even if you have used a functional language, you might find something new: for me, the assignment on “functional sets”
(implementing the Set abstraction in pure code) was particularly interesting. And if you're using Scala professionally, I think it's worthwhile
to see how the creator of the language approaches problems.
I'll finish with an unexpected insight: Java's generics implementation — and in particular, that parameterized collections
don't behave like arrays — was 100% intentional. I'm not sure if
you'll be able to watch this lecture, but if you do, you'll see (about
7 minutes in) Odersky explain how Java arrays are bad because they don't allow the compiler to catch certain type errors (the same material is also
covered in Programming in Scala). After seeing this, I dug up the JSR-14
spec, and saw that yes, Odersky was one of the people responsible.
*
Actually, it may be possible to watch on a plane; a quick session with Firebug indicates that the videos are straightforward HTML5. I
haven't looked at the code behind them, so it's possible that the quizzes are implemented in JavaScript.
**
My concern is that the assignments distribute logic rather than encapsulate it. A more egregious example, but one less open to explication,
is in a later assignment: defining a simple type alias to represent a list of pairs. What the simple alias does not convey, however, is that
the list must remain sorted. An object-oriented approach would maintain this invariant in the class; consumers would never see/create an
unsorted list. The functional approach, by comparison, requires every function that transforms the list to maintain the invariant.
