HN Academy

The best online courses of Hacker News.

Hacker News Comments on
Functional Programming in Scala

Coursera · École Polytechnique Fédérale de Lausanne · 227 HN points · 29 HN comments

HN Academy has aggregated all Hacker News stories and comments that mention Coursera's "Functional Programming in Scala" from École Polytechnique Fédérale de Lausanne.
Course Description

Scala ProgrammingParallel ComputingApache SparkFunctional ProgrammingRecursionImmutable Data TypesHigher-Order FunctionLazinessType ClassReferential TransparencyReactive ProgrammingData Structure

HN Academy Rankings
  • Ranked #4 all time · view
Provider Info
This course is offered by École Polytechnique Fédérale de Lausanne on the Coursera platform.
HN Academy may receive a referral commission when you make purchases on sites after clicking through links on this page. Most courses are available for free with the option to purchase a completion certificate.
See also: all Reddit discussions that mention this course at

Hacker News Stories and Comments

All the comments and stories posted to Hacker News that reference this url.
I took the Functional Programming Principles in Scala class on Coursera and it was excellent! It's taught by Martin Odersky who is the creator of the language, and had lots of very effective short exercises which let you apply the concepts he teaches in the class.

Yeah, definitely!

First/foremost, the community essentially held my hand, especially during the early weeks. I would ask questions on their Discord and always someone would answer them and explain concepts if needed:

They have a great community. The experienced users tend to be heavily FP-oriented but they're respectful of the "I'm not really the Haskell type." sentiment.

I went through the Scala 3 "concepts" book on the website, and then started to build things + ask questions about best practices or how to do stuff on Discord:

They have also updated the free online courses "Effective Scala" and the Scala specialization to Scala 3:

Thanks I'll take a look
I can think of many - I have taken several starting since 2013. The tricky thing is that Coursera classes seem to get merged, re-mashed or otherwise re-branded. And as such only one currently is listed in my "Completed" courses section of my profile.

Having said that and with the caveat that these probably changed since I taken them, I recommend the following:

- Cryptography - - great introduction to the fundamentals and math behind cryptography. A lot of theory but also some practical exercises. This is my top recommended.

- Machine Learning - - a good introduction to the basic of machine learning; focuses on octave/matlab and does not dive into frameworks like scikitlearn or tensorflow

- Introduction to Interactive Programming with Python - - I took a course from Rice University on Python programming through making games that was fun. As far as I can tell, this is the modern incarnation in two parts.

- Software Security - - goes into stack / overflow exploits, tools for testing, and web-based attacks

- Functional Programming Principles in Scala - - this was a good introduction to scala and functional programming - it got me thinking in a different way

- C++ for C Programmers - - I think this was the first coursera class I took. This course dove into the C++ STL and a lot of modern features introduced in C++11.

> as such only one currently is listed in my "Completed" courses section of my profile.

That's surprising to me: wouldn't Coursera want learners to be reassured that whatever signalling benefit there is to completing a course will remain forever?

I took a few courses in 2013 just to see what MOOCs are really like and completed two (Programming Languages, as taken by many here, and Introduction to Mathematical Thinking, which IIRC was mostly about logic) which indeed are not listed under "completed" in my profile. I found them at though.

> I found them at though.

Thanks for pointing that out! I have 11 courses in the accomplishments and just one in "completed" courses.

The first two course of the specialization on functional programming by Scala's founding father is worth your time if you're into that. I remember it being quite challenging, but gives you a thorough grasp of FP, and a new language in your toolkit.

Not GP, but: I recommend Standard ML. I can't see a better way to do this than to power through Dan Grossman's three course sequence, which goes back to the drawing board and teaches Standard ML [0] to introduce modern programming language features such as scope, closures, types, pattern matching, modules, and so on. Then, he uses the concepts introduced in Standard ML as a springboard to introduce Scheme in the second course, and Ruby in the third course. And in the end, you will see how each of the three languages implement in different ways the same powerful techniques.

But with just that first Standard ML course, you can already branch out to more popular languages such as Scala [1], which gives you the closest thing I've seen to "Standard ML on the JVM". But Standard ML (or Ocaml, which is very close) might even be your preferred language for prototyping [2], or compiler writing [3].

P.S.: To make Coursera tolerable, I usually pull the entire course with this nice little script [4]. Works great with ranger and mplayer!






> Uses script to copy programming course.

That's a little meta, don't you think?

Welcome to Lisp: :-)
thank you!
Caveat emptor: Standard ML is not widely used in industry and does not have a large library ecosystem, so if you do recommend it to clients, make sure it's clear that they'd want to follow up with something like Scala or Ocaml, which have far more users/libraries. It's just that for really understanding functional programming, Standard ML is fantastically clear. (Although actually, that Scala coursera course I linked to above is by Martin Odersky, and is also pretty darn good, especially if you're already committed to the JVM.)

Others have mentioned Elixir, which would also be an interesting option to explore. The main difference being that with Elixir you're leveraging Erlang and BEAM (which gives you a fantastic platform for actors and lightweight threads), versus Java and the JVM in the case of Scala (which gives you access to all of Java).

I almost forgot to mention: Matt Might has an excellent blog post about what all of these "advanced" programming languages offer:
There's a Coursera specialization on Scala[1], however it seems to focus more on data analysis than web development.


I didnt think the Scala Coursera was very good for general developers - a bit too academic and focusing on functional / recursive patterns which aren't a good way to get a feel for the language in everyday web usage (vs Php, Java, etc).

I'd recommend the book 'Scala for the Impatient', tutorials and projects from Twitter, and Maven or SBT template projects.

If you're worried about your resume, just use the down time to pad it with new skills.

Maybe something like this?

Haskell forces you to think in a certain way. So if you want to learn about functional programming, then when you're searching for programming examples all those examples will be in a functional style. You can then apply those styles to Scala or F#. Personally I'd lean towards Scala (on the back of Spark) - there's the Coursera Scala Functional Programming course [1] which will give you a good start.

That's interesting. Just a few days ago with great regret I decided to drop the (free) Scala course on Coursera after almost finishing week #3 (of 5 I think). I'm actually already pretty familiar at least with the essentials of functional programming but would like to go even deeper.

However, I found the step too steep between the easy to understand lectures and the exercises, and the latter not as useful as they could be. It felt like I was suddenly dropped off and left to my own devices with no guidance. "Now implement this!" Uhm... what? Sure, that's easy, I've been implementing much more complicated things for decades. The problem is I have no idea how to approach it "the right way" as far as Scala is concerned, that's why I'm taking the course!

Looking at the forum - extremely sparsely populated even after over 4 months - showed that I could also expect no guidance from there. That meant that even when I finished a task I was unable to find out if what I had done was the right (functional) way. For one and most importantly, there is hardly anyone to respond, but also since the only exercises are the homework assignments you can't just post your code, that's an "honor code violation". There also is no "solution", i.e. you can't see how the course author(s) would have implemented it.

Another example, people in the forum complained about extreme differences in performance for very minor differences in the way you wrote something, and you had to find all of this out completely for yourself, again no guidance at all.

Another point is that I found the problems too academic. Sure, I can walk a list of head.tail or a tree of left.element.right tuples. But overall the problems were all from what I did a long time ago at university and it felt very, very far from what I deal with now - and I don't just do CRUD or other boring stuff and actually do have interesting algorithms to implement. The course feels like being made for university students - in a negative way.

Overall I found the course more frustration than it was worth. I could have solved the programming challenges easily enough in a way I already knew, but what's the point? I wanted to learn the new (Scala) way, but felt all alone in trying to do that.

The course was like a good violin player demonstrating a piece and then giving me some sheet music and shoving me out the door "come back when you can play that". It's hard to complain about "free", but if course forum participation is a guide, both total numbers as well as the steep drop-off after week 1 and 2, it isn't very successful.

The course:

Note: Enrolling in the courses individually is possible for free, going through the "specialization" page at only shows the for-pay option.

I actually liked the progfun1 course, which I took a few years ago. It's one of the cleanest courses I've taken on Coursera. It's true that it's slightly "academic", but that's what many introductions to functional programming often feel like.

However, the follow-up courses, Reactive Programming (retired) and Functional Program Design, are a total let down. They are a rip-off, especially if you paid for them: a complete mess, no relation between lectures and assignments, no introduction of new concepts in relation to a greater context, the slides are not proof-read, constant mentions to non-existent slides and lectures, repeat material from previous courses (a side-effect of the courses being mash-ups of previous material), and example code that doesn't type-check or compile. It's not any single mistake, but the aggregation of them all, and the feeling that the authors just don't care enough. Thankfully I didn't pay for this.

In my opinion, the gold standard for Coursera is Dan Grossman's excellent Programming Languages, which I fully recommend.

Have to say, I loved Dan Grossman's work teaching SML. Quite a few of those lecture videos had lightbulb moments for me.
I share the exact same story. Progfun is a really smooth introdu tion to FP in my opinion, no crazy syntax and only the core concepts. For any deeper concepts and if you don't understand what FP really means you should check out a purely functional language.
Just to clarify my opinion on progfun: The lectures are good.

The coding tasks could have been okay - if there was any guidance. I don't even get to see any sample solutions. So even if I make it work, I don't know if that is a good way to do it, the "functional", the "Scala way". And the performance issue I mentioned, it was a major one, the difference between the code even being usable for more than a thousand elements in the list or getting a stack overflow, and the difference was extremely minor, in one case the order in which you called "union" on sets. All of that had to be found out by the students, and even after they found out nobody really had a good idea or explanation for why it was so.

Also, there only was one (small!) opportunity to actually practice what you just learned per week - and that came without any feedback apart from "works/doesn't". Since the course was about a particular programming style that really wasn't enough.

Aug 07, 2016 · noname123 on Ask HN: Technology stall
My suggestion is to try to audit a series of courses. This will force you to concentrate on a particular theme; some of the courses are not self-paced and have a deadline to finish problem-sets (which are Juyptor notebooks where you have to actually do the work, and fill-in the code snippet but not to muck around with setting up annoying IDE/dev environment, autograded with unit tests), so will force you to stick to deadlines.

Here are some of courses that you might (read: actually I am) interested. (3 courses on Apache Spark using PySpark and introduction to simple machine learning and distributed computing) (3 courses on R, next-gen genomics sequencing, annotation and some more cool computation protocols involved with CHIP-Seq and RNA-seq). (4 courses + capstone, spearheaded by Martin Odersky; the guy who is the big-wig in the Scala community).

Also, I'd recommend taking the verified tracks for all of them. This will force you to complete them as money is on the line (if possible ask HR/your boss if it's related to your work, for tuition reimbursement benefit).

I recommend taking the specializations, but don't expect you will be able to reimburse them as Coursera is unable to provide invoices.


Jun 09, 2016 · 2 points, 0 comments · submitted by tu7001
May 23, 2016 · 3 points, 0 comments · submitted by adil_b
May 20, 2016 · 2 points, 0 comments · submitted by tomh-
My Coursera profile lists 67 courses, I have completed ~15 of them and with a passing grade ~8 of them. My most favorite one, which for me was the hardest as well, was The Hardware/Software Interface by Gaetano Borriello and Luis Ceze[1]. I also liked Computer Networks[2] even though it's an introductory course, Functional Programming Principles in Scala[3] which is surprisingly easy unlike the follow up course[4], High Performance Scientific Computing[5], Software Security[6] and Cryptography[7] although I prefer Boneh's class. For non-IT related courses I liked Think Again: How to Reason and Argue[8], Crafting an Effective Writer: Tools of the Trade (Fundamental English Writing)[9], Child Nutrition and Cooking[10] and Work Smarter, Not Harder: Time Management for Personal & Professional Productivity[11].

I often take time to think why I have so many started but not finished courses. Most of them are abandoned on the first week and my assumption is that when I enroll my expectations for the course content and the workload needed are wrong.

Occasionally, I abandon courses because they demand too much time to get something working on linux or because of luck of time. The thing that I noticed about me is that when I get a little behind the schedule then it's almost certainly that I will abandon the course. Additionally, when I try to commit on two courses at the same time then it's certain that I will abandon at least one (usually both).












Jul 20, 2015 · nextstepguy on Monads in JavaScript
Taking that (free) class on coursera was an eye opener on all the things that are discussed in this article. Highly recommended:

This looks awesome. I wish there was way to watch the videos of the course.
I was able to "join" the course for free and all of the videos are available.
Agreed with it basically being lots of hard work, and that you have to be very motivated.

I'm currently 29, working as a Software Developer, and also started late. Got my MSc in Oceanography, had some basic programming experience (built basic websites for beer money, some light scientific programming), but not much. Decided I liked the analytics more than the rest of science, and got a job at a SaaS company as a Data Analyst. Really started falling in love with programming quickly there, and did the following: - took online courses like crazy (often waking up early to get some in before work, and more on evenings/weekends when possible) - always took on the most technical tasks at work, where I'd get to write as much Python/R/SQL as possible - started a coding club at work, great for group learning and motivation

After ~2 years of this I had gotten myself to a point where I could legitimately work as a Software Developer, and got a new job as one (at the same company). Stayed in my area of expertise, data science/analytics, but as a developer instead of an analyst.

I wouldn't suggest codeacademy, though. Maybe it's changed since I tried it, but my experience was that they introduced you to a bunch of syntax, but left out most of the fundamentals of how computer science and how to structure programs. I'd much more strongly suggest taking more involved courses. Some of my favourites include (note - bias towards Python, Scala and SQL courses, as that's what I happen to use a lot of):

Intro to Comp Sci (Python)

Intro to Web Dev (Python)

Data Structures and Algos (Python):

JS intro:

Functional programming (Scala):

Reactive programming (Scala):

Good databases courses (boring but good content):

My personal feeling is that things like codeacademy get you superficial knowledge, like learning to use tools, when what you really want is deeper knowledge about how to build houses, regardless of the tools.

If this interests you, definitely consider taking
Mar 11, 2015 · 2 points, 0 comments · submitted by exelib
I found this to be a great introductory course to the topic (Eric Meijer is one of the instructors):

> if you're throwing punches you should know what you're talking about.

Ironically, I think you completely missed his point, probably because of an unfamiliarity with his background and history. He's not dismissive of reactive programming at all, quite the opposite! For example, he gave a course on Coursera about Functional Reactive Programming with Martin Odersky and Thomas Kuhn[0].

So my take on it is that he's just making fun of himself and his friends in a typical blunt Dutch fashion. Which of course doesn't work if you don't know the context.


Cool, I'm totally open to the possibility that I missed the self-deprecating shtick from lack of context. If so, mea culpa.
Very interesting. By the way if someone is interested in more details about Reactive programming, there is a great coursera course about it (
This is an interesting topic, which I've been thinking about a lot. It seems like ten years later, we have the same duality going, but with successor models. We've gotten rid of the shared state that makes threading a pain to yield Actor Model/CSP and we've reified callbacks into promises/futures, events into streams, and mutable data into signals to make each encapsulated and composable in Reactive frameworks. It seems that the former model has really taken off in imperative programming and the latter in functional style.

A paper from EPFL [1] does a great job of breaking down the problems of the Observer/Event pattern and how reactive patterns shore up the workflow. It also contrasts the resulting framework with others, including actor models. Interestingly, both models seem to have settled on message passing, the main difference being whether it's the sender's or receiver's responsibility to initiate the connection. In an actor model, the sender must know the receiver's address in advance, and receivers generally accept messages from anywhere. In a reactive model, receivers are responsible for connecting to a message source, and the sender has no control over whom receives its messages. Unsurprisingly, since Odersky is one of the authors of the paper, Scala has a great deal of support for both models.

I'm not sure I fully understand the contrast between the models. The Principles of Reactive Programming [in Scala] Coursera course [2] actually devotes subsections to both models respectively, but rather oddly does not make much of a comparison between the two. I haven't read anything that fully explores this duality, or perhaps whether there is a model that generalizes/unifies them.

Does anyone know of good resources on this topic?



Have you seen the follow up course "Principles of Reactive Programming" too?

It's also by Martin Odersky, but also with Erik Meijer and Roland Kuhn.

I did start that course, but after the first 2-3 videos I couldn't find the time to continue working through it. Back then I was working on a customer project that required a lot of attention. I may want to try it again the next time that it is being offered.
I took both classes, but I really didn't care for Reactive as much. The first Coursera class really turned me on to the elegance of functional programming with Scala's unique type system, but much of that elegance is really lost dealing with some of the structures introduced in the second class, in my opinion.

Reactive is split into three "subclasses". The beginning part, taught again by Odersky, was a pretty useful extension of what was taught in the first class. As with the first class, the lectures were very well thought out. Although, some of the examples abandon the beauty of side-effect free programming, which was a letdown after really being turned on to that style in the first course.

The middle section on Futures and ScalaRx was pretty rough. Those lectures, done by Erik Meijer (I believe), were less clear and less well planned. I don't know if there's an impedance mismatch between Scala and the reactive style or if ScalaRx is just the wrong abstraction, but the joy of Scala was completely lost for me in these two lectures. I'm used to Javascript's Promises/Deferreds, which are essentially the same thing as Scala's Futures/Promises, but the former are far more intuitive syntactically.

I did, however, find the final three lectures on Akka to be very well taught. I had no experience on actor model programming, but I came away very intrigued by the possibilities.

A complaint that spans all three sections was that the assignments could be better focused on the the concepts at hand. Each can require a fair bit of constructing your own test and debugging frameworks to figure out how to pass the rather opaque and unhelpful automatic grading system. I eventually lost patience and quit doing the assignments after floundering with the tools.

You are most welcome.
I concur. I loved the Functional Programming Principles in Scala course and recommend it to everyone I can. However, I'm not at all sold on the Reactive Programming course.

Erik Meijer's lectures -- at least in the first iteration of the course; maybe they've gotten better -- were riddled with errors, confusing exercises, and an overall lack of coherence with the rest of the course. It pains me to say this because Erik seems like a cheerful guy and I really wanted to like his lectures, but they are a mess.

Even Roland Kuhn's lectures, which are pretty good and a lot clearer than Erik's, didn't manage to sell reactive programming to me. One glaring problem was that the actor model seems to throw away most of Scala's static type checking, which we had learned on the previous functional course. Suddenly it's ok to pass whatever message to actors in a way that seems closer to dynamic typing.

I've always found this to be a strange duality in the Scala community. On the one hand they praise strong, static type checking in general Scala programming, and on the other hand they praise an almost untyped paradigm in the actor model. And few people seem to take issue with this.
Plenty of people don't like this aspect of Akka. Most of them are using scalaz-stream instead.

See and

Feb 11, 2014 · joncooper on Toward Go 1.3
Gee, an entire course on functional reactive programming rather than a link to the FRP idioms enabled by generics? For me? Gee thanks.
I was having a chat with someone this morning and said that I thought stream processing would be big in 2014 in response to reactive programming [1].

I'm checking out Kafka [2] and Storm [3] over the holidays in preperation for this.

[1] [2] [3]

I believe Spark [1] might take the place of Storm as it unifies streaming and batch processing.


Probably a good call.

CEP (Complex Event Processing) has been used in trading systems since about 2004, earliest I've heard of. By about 2008, it was widely in use in the industry.

It's now considered an old technology, meaning it has to be part of your tool box but no longer gives you any competitive advantage.

I don't see it going away, but the biggest problems with it now is its speed.

Solve how to you guarantee that a signal will flow through your system in a guaranteed time and you can make some money.

Or put another way, trading systems are often like video games. Just like how video games engines limit the time an engine has to draw a frame a trading system will limit the time it takes to make a buy/sell decision based on an input.

TL/DR CEP or streaming architectures often don't guarentee all rules will be run over an input in a guarenteed time frame.

Dec 11, 2013 · arethuza on Reactive Manifesto
Personally, I found the outline of the Coursera course you mentioned a lot more interesting than the "manifesto":

I was reading up on Monads because of the reactive course. [0] I translated the code in "Monads for functional programming" (the linked paper) to Python a few weeks back – [1]

Not sure if it will actually help anyone, but it did help me in realising that I had not understood some code, but had instead just glossed over it. The State Monad, for example. [2]





Your timing could not have been better. There's a reactive programming course going on Coursera right now. Tomorrow we will start the part that introduces Akka. You can still enroll in the class.

Nov 28, 2013 · rz2k on Choosing Scala
Are you aware of the follow-on course?

Yes, I am following that course, thank you! Although due to crunch at work I am not doing assignments for this one.
Created an account to test it out. Looks good. But I wasn't able to find Reactive Programming[0] class but I assume new classes are still being loaded and added.

A suggested feature, and one I've considered doing myself, is to have a sort of timeline of classes. So that if I sign up for a class from November to January, and one from December to February, it would show that they overlap during December and January. One of the biggest problems I have is biting off more then I can chew, and what I like to do is visualize each class as a per week load and stack them on top of each other. That way I can find bottle necks where several classes might overlap in the final and beginning weeks leaving me with an expected work load of 30+ hours.

All and all it looks great.


Sep 20, 2013 · vassvdm on What’s new in Play 2.2
BTW if you're interested, Martin Odersky and others will host a brand new Coursera class focusing on Reactive programming starting in November:

It doesn't say so explicitly in the course description, but I guess we will be using Play and Akka during assignments. If it's half as good as his introduction to Functional Programming in Scala, it will be a treat.

I have similar feelings about Scala. Combines functional programming w/ a strong/static type system and all the benefits of the JVM. Very practical and fun which I found was not the case w/ Haskell and ML languages. And you couldn't ask for better timing, first day of class starts tomorrow[1]! (and in a month and a half, reactive programming[2])

1 - 2 -

Can you please tell me more about your experience with Haskell?
One ding to Scala's practicality, it's such an enormous language that to use it in production with a large team almost requires a C++ level of discipline in deciding which elements of the language to use. It's a terrific language though and the fact that it runs on the JVM is a huge advantage.
Sep 10, 2013 · jjsz on PayPal hardware powered by Go
Thanks, I knew about Revel and mgo.

I just forgot to say: a FRP* [0] Go equivalent of Play and that there's nothing like these upcoming Coursera courses [1] [2] for Go with examples.




Aug 28, 2013 · 1 points, 0 comments · submitted by kailuowang
Aug 27, 2013 · 215 points, 47 comments · submitted by steveb
I don't think I've ever signed up for something more quickly than when I saw this announcement pop up on Twitter. Really enjoyed the Functional Programming with Scala course when it ran last year, and I'm happy to see the sequel come to fruition.
The Functional Programming class I took last year was pretty much as good as the expensive CS courses I took at Big Name U. Oh, and it happened to be taught by the guy that invented Scala. I'll admit it, I'm turning into a Coursera fanboy.
Note that the Functional course is a recommended prerequisite for the Reactive one and the former runs again at the beginning of September, meaning you can do both in sequence.
Is there a place to download coursera videos like you can with Udacity? I'm really interested in the Scala course, but it just kind of sucks that it can only be taken during a certain time frame. I've been working my way through Programming in Scala, but the course seems like it'd be a great compliment for understanding the "functional" style of programming.

As it is now, I feel I'm simply a compiler which translates my imperative Python background into Scala syntax.

If you go on the course page

You see archives of the two previous iterations of the course. Their material is always available, and you can stream or download the videos from there.

Huh, I don't see any archive links on that page, where are they?
It may just be for people who previously took the class, I haven't taken it and cannot find any of the archives mentioned by modersky, but I can find it on other courses I have taken
It looks like you are right. Only enrolled students can see the material and enrollment is closed for the previous sessions. I'll check whether there's a practical way to make the material available.
That would be great, very likely won't have time to participate in the Scala FP course this session, but would love to see the videos regardless.
Count me in here. Would love access to lectures or videos.
While the course is running (at least for the course I'm currently enrolled in) every video has a download icon at the far right.

At times (for me), the time-based nature of coursera is a very good thing. If I know that I need to complete a homework by 1am Sunday night, which means I need to finish watching this week's videos by Thursday night, that means there's a chance I'll actually do so. Without that deadline (and with no money or grade on the line) HN or Reddit or other timewasters are far too tempting.

Me too, a deadline really forces me to get down to studying, it's all too easy to let life get in the way otherwise!
Fantastic! I've been wanting to learn FRP for quite some time. The fact that this is a follow-up to the awesome Scala course is a bonus.

I can't wait for this to begin. =)

EDIT: The syllabus doesn't mention any FRP libs. I'm surprised, especially as one of the professors is the author of RX. Maybe because there isn't a canonical one in Scala?

One of the blog posts[1] I saw announcing it had a few more details than the course page, including a mention of RxJava.


They don't mention FRP. RX is a subset of FRP oriented around just event streams without continuous signals; think of it as FRP lite. Their actors and futures unit makes me wonder if this is also about concurrency in addition to reactivity. Nothing about state repair at all.

If Conal Elliott ever decides to teach a coursera on FRP...

In case you didn't notice, this course is being co-instructed by Erik Meijer, creator of the fantastic reactive extensions for .NET library.

I encourage anybody who has to write or maintain more than a few lines of C# or .NET code to check them out (and possibly take this class if it turns out to be good).

If you're into FRP in .NET, please checkout the OLINQ project on github. It lets you define LINQ queries against reactive sources and have them update themselves as the sources change, letting you do things like realtime aggregation in a couple of lines of code.

I think it's wickles.

Back when Borders was still around I stumbled upon a Functional Reactive Programming book by Paul Hudak. To this day it's still one of my favorites. If you know Haskell and don't want to learn Scala, you might enjoy this as an alternative to the course. The book is called The Haskell School of Expression: Learning Functional Programming through Multimedia.

Amazon link:

As far as I know, Hudak has updated and renamed his book to The Haskell School of Music, and it's available for free from the Yale Haskell Group's website here:

The book is a really awesome way to learn Haskell. However, very little of it is actually about FRP; there's one section about GUIs using FRP, and it doesn't go very much in depth.

Pretty sure that's just a different book by the same author. "Updating" a book on graphics to make it about music instead doesn't sound like a second edition kind of maneuver.
... especially true for one dealing with an "immutable" programming language


Typesafe also just announced a tutoring program for this and the intro course.

I haven't taken Odersky's first course, but I'm fluent in Java and Clojure. Do you guys think that would suffice or will Scala knowledge be a prerequisite?
It starts in two months so could give Martins books a read. And I think that would be enough. Some of the lectures were based on his book and others on SICP.
If you're well versed in Clojure and FP principles, the only difference for you would be in picking up Scala syntax, in my opinion.
I'd say the type system is a non-negligible difference. Still, knowing Java and Clojure is a good foundation for learning Scala.
you won't have trouble. that said, the first Scala course is excellent independent of its use of Scala because of its fun/challenging homework assignments
The prerequisite course starts in about 2 weeks [1], so you can still take it if you want before Principles of Reactive Programming starts, you'll be able to see what parts you feel you can skip and which ones are useful. There are other quick introductions to Scala you can take [2],[3],[4] to get a feeling of it.





This is a follow on course to Functioal Programming with Scala, and led by Martin Odersky, Erik Meijer and Roland Kuhn. Signed up
This is the most awkward introduction video Ive seen so far. I really enjoyed Erik's introductory course on haskell so really looking forward to this course.
Yes, sorry for the video :-) We had just 1 hour in the same place together, and that was in a hotel conference room and we were all tired from our respective conferences. We'll shoot another one when we meet next and will replace the video then.
Cool, I got a response from Martin Odersky. I really enjoyed your course on scala :) so looking forward to this one.
Signed Up!! The Functional Programming with Scala Course was very good.
Note: this is not about “FRP”

(if you don't believe me —

That's a good thing to point out. The "reactive programming" in the course title comes not from the acronym FRP but from this:

This is awesome news. I really enjoyed the Functional Programming with Scala course and can't hide my excitement for this one.

This is also interesting to me because it shows that teaching and learning does not have to be at some big name University.

Can some explain like I'm 5 the tradeoffs between Go/Scala/JS[node.js]? I've been googlin', and there aren't enough articles that compare and contrast the three.
Without being an expert on any of them:

* Go: statically typed, no type parametrization, good support for CSP-like concurrency, deeply imperative language. Proponents site its speed of compilation, simplicity, and growing community.

* Scala: statically typed, modern and sophisticated type system, supports OO and functional programming, runs on the JVM, has good concurrency support.

I really don't know enough about Node.js to say anything about it. It's Javascript, so it's dynamic typing and a mix of OO and functional programming.

Go is supposed to be a better C.

Scala is supposed to be a better Java.

JS is supposed to be popular.

EDIT: Go is intended to be a systems-programming language with an emphasis not only on runtime efficiency and concurrency, but additionally on such things as compilation speed.

Scala is intended to be a hybrid OO-functional language that is approachable by a broad class of mainstream programmers (i.e., Java programmers), with a type system considerably more sophisticated than Java. The emphasis is, I'd say, on a language that has long-term potential, at the cost of a somewhat problematic toolchain.

JavaScript's enormous advantages are that it is universally available, easy to approach, and flexible enough to support functional techniques.

My only complain it's in Scala. I wish there were the same course but in Haskell.
Hm, did Erik left Microsoft for Applied Duality, Inc. ?
Yes, but work continues on Rx with MS Open Tech and Microsoft, especially since it is open source. * Disclaimer * I am an Rx team member
Thanks, as it says, Brian Beckman has also left MS.
I think this course looks like it could be a lot of fun. Erik Meijer is a great teacher with lots of enthusiasm. The introductory video makes it look like we just walked in on a particularly awkward moment, though, like they set the bench they're all sitting on down in a suspiciously bad smelling elevator car.

If you haven't see Erik Meijer's haskell course and are interested in that type of thing, check it out:

It uses this really great book by Graham Hutton called Programming in Haskell.

The course is awesome! Highly recommended.
Programming in Haskell is an excellent book, I liked it a lot more than some of the usual recommendations (Learn You a Haskell, etc).
HN Academy is an independent project and is not operated by Y Combinator, Coursera, edX, or any of the universities and other institutions providing courses.
~ yaj@
;laksdfhjdhksalkfj more things ~ Privacy Policy ~
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.