Today's entry will be rather short and more of an advert than anything else! I really wanted to write this last week but oh well life happens.
I'm pretty sure most of you are already well aware of what MOOCs are and that Coursera is one of the most popular examples (and if you're not go and check it out, it's really worth it!).
Last week a great course on Functional Programming in Scala, done by the Martin Odersky, was concluded. If you are looking for an easy way to get dirty with FP and/or Scala I think that's the way to go. You can still check the course/do the assignments even after it's closed!
But there's also good news! Last Monday a new course launched Principles of Reactive Programming. I think we can safely say that this is a continuation of the previous course. Why should you care? Well let's start with the crew:
- Martin Odersky - the creator of Scala and a huge contributor to the Java language,
- Erik Meijer - a person who requires no introduction in FP circles, he also create the Reactive programming framework for .Net while working at MS
- Roland Kuhn - leader of the Akka project
Hard to ask for a better line-up! But ok, what is this reactive programming? It all started with the reactive manifesto. Basically the whole thing tries to address all the problems that are all the rage currently in the industry: handling a lot of data, being always up and running etc. The main points from the manifesto are:
- being event-driven - this is the main building block which results in a lot of other good things mentioned below. This might sound scary but basically means that we are waiting for something to happen and react to it when it occurs (for instance you send a message from one server to the other).
- scalability - who isn't scalable today? When you're not scalable then you're not cool! Reactive programming is supposed to give you the possibility to scale out both horizontally and vertically since everything has to be very loosely couples and interact with each other only via events. Since FP and RP doesn't encourage having state then thanks to the event driven architecture adding X more services of the same type is a (in theory) trivial task!.
- resilience - since everything is very loosely coupled it, again in theory, shouldn't be a problem if one part of the system fails.
- responsiveness - and we don't mean that your website will look good on your tablet, PC and mobile phone! Again since the whole system is loosely coupled it shouldn't be hard to make it so the user doesn't wait for all the data on the server side to be loaded/computed for hours.
This is a very basic summary of the whole manifesto so I do encourage you to go and read the whole thing! But as you can see the main point here is to change the way you think about architecting your system. It tells you that scalability, failures etc. are not an exception and something that can be quick fixed after you coded the whole but you should take all of it into considering during your design phase!
The course will be divided into three parts:
- Functional programming - covered by prof. Odersky will be a (very) short review of Scala and FP in general
- Futures and reactive programming - Erik Meijer
- Actors and distributed actors - Roland Kuhn
As a prerequisite you should know some Scala, you can check the list of lectures that were given during the FP/Scala course to get a good view what you should know, but I think that having some background in any FP language will be enough. As I said this course already started last week (on Monday) but it's not too late to start now! Will it be worth it? Hard to say since this is the first edition but I will definitely post a write-up after it finishes in December (or somewhere along the way should anything interesting appear!).