A great follow up to the previous course. The planned content is great but the last week goes too fast and the last part about Future is very inadequate to understand Futures well. Also please add more content on Monads.

A valuable extension of the ideas in the first course. Helped to continue to build confidence in using Scala and introduced

Very challenging course, would be better to expand this course into a more detailed and slower paced version

Apart from week 4, I found all classes very instructive and relevant. The video's from Erik Meijer in week 4 seemed a bit artificial. The exercise in week 3 was not really related to the classes other than that we learned in the course that there is a way to proove something and then we needed to. I could not really understand why or when I would apply that knowledge.

The introduction to functional reactive programming is well done. You go from the problem to the solution in a few lectures, and understand positive and negative aspects of the approach.

Last week passes by the subjects superficially

Great course! Lacked the same polish as the previous course though. Week3 assignment had grading issues.

Very good and well-paced course. I'd give 5/5, but there are parts that seem to be missing -- lecturers refer to videos that aren't part of the course (or the previous one: Functional Programming Principles in Scala). Overall 4/5.

Less material and practical tasks than in the first Scala course, also some bits about Reactive programming were just taken from other course, but not fully, just partially!

The content is excellent (as always), however the form leaves a bit to be desired. The video quality kept reverting to "low", and even on "high", the resolution was nothing to be proud of in 2016 (or at any time during this century). Also, the instructors appeared to make references to lectures that are not a part of this edition of the course. But these are small issues – the course is definitely worth taking, small imperfections or not.

The content is excellent. It needs to be better organized. We learnt a lot about Monads, Futures, etc, but there was nothing to test them.

Week4 organization requires a lot more work. It appeared as though, the professors have taken some other course content and re purposed it for this course. While that in itself is not bad, what has happened unfortunately is that the jumps in the lectures are very sudden and many things do not make sense.

Some of the "inductive programming" proofs are quite long and tedious and does not gel with the flow of the course.

The course material and assignments did not quite match. Moreover, the test assignment was like something for completely another course. Not even a word about possible ways to implement test assignment methods. Had to browse around course forums and browse around the Internet for additional materials about Scala and algorithms. Although in the end got 10/10 points - no idea whether same result could be achieved in some even more elegant way.

Course material was not difficult, but the homeworks weren't much correlated with it. If you attend other IT online courses you will notice that this one is a little old fashioned. I was also more interested in real-life usages than how it should be implemented. Regardless the cons course was informative and somehow useful.

exposure to libraries and advanced features of scala

Great class, though the content seemed less coherent than the first course. Topics tended to bounce around without enough deep dives into the more abstract ideas.

This course is OK as a successor of "Functional Programming Principles in Scala". You definitely learn a lot of new functional concept, the material is presented well and the homework is engaging (though it is debatable if it couldn't be more closely related to the course content).

Participants should know, though, that this is a condensed version of a previous Coursera course by the same authors, "Principles of Reactive Programming", which is no longer available. Compared to the earlier course, the present course is less coherent – it consists more or less of a subset of the earlier course’s lectures (videos). As a consequence, the instructors sometimes refer to earlier or later lectures that are not actually there (or at least not in the expected order). (I recommend participants to look up the missing lectures on Youtube: https://www.youtube.com/playlist?list=PLMhMDErmC1TdBMxd3KnRfYiBV2ELvLyxN)

Lastly, I do not think the title "Functional Program Design" is appropriate. I would call it "Elements of Reactive Programming in Scala" or something similar.

Thanks EPFL good course and has certainly broaden my awareness of the possibilities of using Scala.

Great course, however, I needed more time than was suggested

This one is a bit overpriced, but interesting and useful.

Maybe an unfair comparison but I am comparing this with the principles of reactive programming. That had much more contents such as actors, etc. Having said that this is a good course by itself.

Very interesting course. Four stars instead of five because it was less about "Program Design" (from the title) than I would have liked.

The assignments seemed somewhat easy compared to curriculum which became more difficult. I would say that the assignments from the first course were more challenging then those from the second. I also think very little attention was paid to new monad constructs like Try, Validate and scala's reactive library, but I guess the later was left for the third course.

Thanks for this course!

Only one times i was very confused - when i saw that in the last assignment i should use Vars and Signals, not Features and Promises - that's, i think, a little bit far from as async code in real projects, which contain promises, features, actors etc.

But anyway, thanks for all of that, it was useful for me.

A very good course (4.5 in my eyes) the only thing for me that was lacking straight after previous course was a bigger difficulty between videos and programming excises. But maybe that's my lack of Scala experience.

Overall learned a lot. Some contents are hard to follow but using supplementary material helped me to discover new things about scala.