PoRP (https://www.coursera.org/course/reactive) is a first on-line course on Coursera I’ve participated in. It’s a follow-up to "Principles of Functional Programming in Scala" and it’s recommended to go through this one first, but I decided to head straight through PoRP and I’ve managed (but I wasn’t new neither to Scala nor to Rx, so if you are, I’d rather recommend not to jump in at the deep end).
Briefly speaking - it was an awesome experience and I liked it a lot. It required some effort and it was time-consuming (having an important project in the same time doesn’t really help), but I’ve really learned something I find useful. If you care about more details …
What was good and what was … not-so-good:
The Good Parts:
- Topic itself (reactive programiming) - RP is getting more vocal every day (check http://www.reactivemanifesto.org/) - number of event-driven framework and libraries is constantly increasing, praise of immutability is common and functional programming has its great come-back.
- The lecturers - I’m not even should whether I should really elaborate that: these people don’t really need being introduced:
- It was PRACTICAL - yes, every week (course took 7 weeks) there were around 1.5-2h of video lectures, but the clue were the practical assignments - you had to do some coding to solve the problems related to topics described in lectures. Assignments were hard enough to make sure you understood the subject, but they were doable within assumed timeframe (I’ve got 100% points for all of them without much stress), That’s the way to REALLY learn something!
- Assignments’ nature forced creation of automated tests - it tasks were to write code (the WORKING code, not a 2-line long illustration example), the best way to make sure you’re doing good was to write tests :D
- Both lectures and assignments were simply speaking - very interesting and enjoyable: I honestly had a lot of fun either watching vids or writing code. Lecturers made sure that participant won’t be bored.
- Responsiveness of course team - if there were any issues, questions, doubts - there were very quickly responded / addressed - on Coursera forums or even via Twitter. Nicely done.
- Great assignment evaluation tooling - SBT + suite of tests for automated evaluation purpose = WIN
So called “Areas To Improve”:
- As it was the first time this course took place, there were some infancy period problems - typos and inconsistencies in videos, some problems with code in assignments (fortunately, these were quickly fixed). These problems were most painful in Rx weeks (3-4) and Akka weeks (5-7) were almost perfect (big kudos for prep).
- Slow start - the initial lectures (by Martin Odersky) were interesting, but they felt like rather lightly related to the main topic. I was impatiently waiting until true reactive programming starts.
- Eclipse IDE as a preferred tool (assignment code was structured to be used with it) - you can call it a personal preference (or lack of it), but I just hate Eclipse. Years are passing by and it’s as bad as it was. I respect TypeSafe for putting a lot of effort in building “official” Scale IDE based on Eclipse, but it’s like building a castle on sand. Yes, you can call be a VS-fanboy as I come from .NET world, but keep in mind that I had no problem with adapting to IntelliJ Idea.
It was both time and effort (6-9 hours * 7 weeks) well spent. I can clearly recommend this course to anyone who already knows basics of Scala and is interested in reactive programming.
Where can I place myself after completing this course? Obviously it didn’t make me an Akka master, but it gave me a nice boost while I’m still igniting.