Organization

The course is organized into video sessions split into 6 weeks, but since it is fully online you can choose your own pace. I completed the course in two weeks while being on a standard working schedule. Each week apart from week 5 has a programming assignment that is submitted to Coursera and automatically graded.

I found the assignments executed very well from a technical perspective and had no issues at all with downloading, compiling, running, and submitting them.

You can submit each assignment as many times as you want, so there is no stress making the submission right on the first try. Once the course is completed, you get a certificate.

Pre-course setup

Since I have prior experience with Scala and sbt, the preparation was not difficult and I was able to get going quickly.

If you are an R user used to conveniently opening RStudio and easily installing packages, you may be surprised by the difficulty of the whole setup. The course does provide setup videos for major platforms, so with a bit of patience, you should be good to go.

Content

Briefly present basic programming paradigms and concepts, model of evaluation of expressions, call by name and call by value strategies, and focuses on recursion, also introducing tail recursion.

Assignment

The assignment is purely recursion oriented - Pascal’s triangle and such. I was able to complete the assignment easily, even though I found the final exercise challenging. My issue with the content was that this felt more like school homework and I was coming into the course looking to improve and gain practical skill with Scala.

Content

The lectures won me over with constructing a custom class for working with rational numbers. This immediately clicked with me and also was very useful, because it walked through creating classes, defining methods and operators, constructors, requirements, and assertions in a very concise and practical way.

Assignment

A different story. The introduction to the problems goes something like

“We represent a set of integers by its characteristic function and define a type alias for this representation.”

I had a bit of intuition around this (and if you come from a CS background this may come as second nature), but if you have neither of those, you might have some terminology to study before you even understand what the assignment is about. This is fine if it is in line with your expectations of the course, but if you came for something practical, thinking about programming recursive transformations on integer sets represented via characteristic functions may not seem like the best investment of your time.

Content

Has a nice explanation of singleton objects and finally, we look at organizing classes, traits, and objects into packages, very nice. Until we are back to recursion again, this time on binary trees.

Assignment

Writing recursive methods on binary trees. I spent way more time thinking about how to do it than programming. The methods are very short once done, but complex to think about, especially if you are not used to thinking about recursive traversal of binary trees.

Also, it got frustrating. The assignment tests were failing because of some predefined timeout that is hard to reproduce locally (you don’t know what tests the grader runs) and you only know when you submit. The issue was to make a recursive method more efficient by placing brackets better around infix operators, which I honestly would not figure out without reading through the course’s discussion board.

Especially frustrating about this is that the video content only covered trivial cases and the assignment asked for far more complex problems. I was close to just quitting the course at this point.

Content

Starts by rewriting Boolean and Integer types as abstract classes - Peano numbers in case of non-negative integers. Quickly flies over subtyping, generics, and pattern matching and shows only trivial examples. The more interesting example, well, go do it yourself! The final video shows a bit of practice with lists programming a recursive insertion sort.

Assignment

Implement Huffman coding methods via binary trees using pattern matching. I had no idea what Huffman coding is, so I had to first research a topic I had no interest in to even understand the assignment. To give a taste, this is one of the exercises:

“Define the function decode which decodes a list of bits which were already encoded using a Huffman tree, given the corresponding coding tree.”

Also, one of the hints, “hint: very simple” was simply priceless.

Content

Week 5 looks at methods available for lists and gives more details behind the intuition. The later sessions even show how we can prove some properties of the recursive methods, which I found interesting. In week 6 we go deeper into the collections is Scala and look at for expressions. We solve the n queens problem with Sets and for expressions. One session is dedicated to Maps, Options, and methods such as groupBy.

As an example, we implement addition of polynomials using these concepts. The conclusion session nicely brings things together by walking through one implementation of the conversion of telephone numbers to sentences. The session looking at Map, Filter, and Reduce methods was very relatable to R’s Map(), Filter(), Reduce() and Position() functions as their design is similar to the corresponding methods in Scala (look at ?Reduce in R for more).

Assignment

There is no assignment in week 5. Week 6 assignment is to compute anagrams of sentences. Compared to the previous assignments I found this one much more fun and interesting, so it felt like a positive ending to the course. Apart from the very first one, this is the only assignment I worked to get a 100% score as I found it motivating. If more of the course had at least this level of practicality, I would have enjoyed it much more.

Scala in VS Code