Review by Antoine Hugueney. He is a software engineer with 2 decades of computerized decision support, animating financial exchanges for over 10 years with real-time chart analysis and streaming.
Took the course? Write your own review here. Read all reviews.
What made me decide to take this class was that I was looking for a follow-up for the much-acclaimed course Functional Programming Principles in Scala which I had already attended last year.
Class Principles of Reactive Programming takes place in the laboratory of prof. Martin Odersky at the Swiss Federal Institute of Technology (EPFL/LAMP). For its 2nd edition from 13th April to 31st May 2015 (7 weeks), this Coursera MOOC Programming once again features 3 parts coming each with its dedicated lecturer.
- Functional programming within a Reactive framework occupies the first two weeks (Martin Odersky).
- The next two weeks focus on Rx, the Reactive Extension stream framework with the 4 fundamental effects of programming (Erik Meijer).
- Akka distributed actor framework take last three weeks (Roland Kuhn).
How can Reactive Programming bring the right answer to the needs of enterprises at large?
- Build within an extensible and resilient architecture what becomes the backbone of digital business.
- Adds better structure to logical architecture of the service with expressive concepts such as futures and actors.
- Network programming, as pervasive as it is, needs solid foundations to be achieved quickly and error-free. In networks too, reactive programming is a game changer, therefore popular frameworks like
- Node.js and Angular are reactive from the ground up. (They just lack the type safety and expressiveness of Scala as taught in this course.)
The 3 lecturers are the 3 leading proponents of the Reactive Manifesto, which is quoted in the presentation of the MOOC. What is this? A collective claim of computer specialists that large systems should be built out of smaller ones proving to be:
– Message Driven.
All 3 lecturers are well-renown specialists of the field. Martin Odersky authored language Scala used throughout this course. Erik Meijer is the creator of Rx framework (Reactive Extensions).
And Roland Kuhn is tech leader of project Akka at Typesafe Inc. Akka is the distributed actors system that melts into Scala foundation.
During this course, Martin Odersky first gives a thorough reminder on Scala functional programming. Then he presents the Signals, a new lightweight tool to handle asynchronous software behavior.
Erik Meijer presents in great details the 4 effects of programming (synchronous and asynchronous, single or multiple). Then he introduces the Scala flavor of his Rx reactive stream extensions. It relies on a solid Java foundation as usual in the Scala world.
Roland Kuhn dives into Akka and its survival design patterns: fault-tolerant, elastic and resilient – hence responsive.
All three speakers have a long practice of teaching their specialty. The tone is clear, concise and simple – yet rigorous at times when more precision is crucial.
Above all, their passion for reactive programming turns out to be communicative and the student immerses himself in increasingly advanced topics.
The course articulates its content around 3 specialties.
- Functional Reactive Programming – FRP. (Martin Odersky)
It begins with a first extension to functional programming. And it gives a quick but deep introduction to Scala 101’s, presenting the monad. These first assignments are of moderate difficulty (the harder Simulations assignment from last session has been abandoned this time).
- Reactive Streams – Rx framework. (Erik Meijer)
This module insists during 2 weeks on the 4 effects of programming: Option and Iteration, Future and Observable. Erik demonstrates the duality principle while keeping it understandable for everyone. Somewhat harder this time, the assignments may represent a barrier to overcome.
- Akka Actors. (Roland Kuhn)
Let’s enter the realm of distributed, Erlang-style actors with Akka Scala framework.
Week 5: Introduction to the Actor Model.
Week 6: Supervision and the error kernel pattern; fault-tolerant and scalable software.
Week 7: Conversation patterns. More elaborate patterns to support large systems or high reliability service (9999’s).
They would be hard to complete alone if it were not for the Coursera forums.
They are undoubtedly the crux of the course. They would be hard to complete alone if it were not for the Coursera forums. These are structured around each week’s assignment. Their help is a much-appreciated resource because both the teachers and the advanced students frequently add essential hints without publishing too much about the definite solution. Well ordered, the forums are actually divided into five sub-forums, depending on whether you are searching about the lectures, the exercises or some other topic.
The last assignment has double points and 2 weeks instead of one (KV store); it is challenging to complete with the full score.
Each part assumes the student has some practice of functional programming but not necessarily to be proficient. A Scala Cheat Sheet and a Reactive Cheat Sheet are even provided on the website to ease the learning curve of students. Assignments are furnished with a reduced test suite but the automatic grading is applied with a more extensive suite. It is up to the student to assemble more tests (the forums can help for this). For this reason, some experience on test driven development is welcome as ever.
This course has changed my vision of computers insofar as programming blends nicely into the reactive business world where streams are ubiquitous.
One could think to extend this learning step with:
– Big Data analysis to take advantage of Reactive Computing scalability capabilities. In Big Data technology Scala is taking a larger share (Apache Spark among others).
– Cloud computing for a similar reason.
BestCerts is looking for reviewers and regular contributors. If you’ve ever finished a MOOC and want to write a critique to help future students considering taking that course, we want to hear from you. Drop us a mail.