Course is not well formed.

I received full grade for second assignment doing nothing.

It will be great if you attach lectures from Reactive Programming at least as optional

At times, this course looks a patch work of videos without a clear continuity. It is a pity that one week has no assessment at all and the last week mostly on "Futures" does not assess them. Also it would have been nice to have a snapshot on Actors

Too fast and dense material is being presented with little practice. For example. lecture on Monad describes what they are but doesn't use them enough in exercises. While i was struggling to grasp topic while viewing the videos and had to view them repeatedly. Exercises were very simple. So I am not sure what they are evaluating. I realise that building an exercise to evaluate this topic is harder too.

This course was significantly less instructive than the first. Assignments did not lead me as constructively through the material. Also the few videos with the other lecturer in week 4 are very confusing, hard to understand, or even appreciate in light of all the other material. I do not think that I have understood futures and am glad it was not required for the last assignment as the answers aren't present in the material.

The lab for the third week was unrelated to the material, and the fourth week is a bunch of videos from the previous course of reactive programming in Scala. Nothing like the first course of Scala

Asigments are too easy to implement

Many of the lectures use concepts that were not introduced before, which is very confusing. On the third week, the lectures are completely disconnected from the assignments. The lectures from the last week feel out of order, but at least the assignment was able to connect everything.

The best thing from this course are the assignments.

I've enjoyed some lectures. But overall, this course was less educative than the first one in the Scala specialisation. I do appreciate Erik Meijer as a professional and a scientist. But, in my humble oppinion, he is not a great lecturer.

The course was good but not as good/detailed as the first one. Martin did an excellent job as usual though. I felt the course content was interesting but got very dull towards the end. The assignments were not really challenging.

I have the sensation that this second part is not so well explained as the first one.

Week 3 was confusing. The assignment is not related to the video contents.

Week 4 was confusing too. The mix between Martin and the other guy's videos is weird. Also I expected much more reactive stuff.

A bit of confusion about the assignment instruction.

The topic very interesting as well as course assignments. But not so good as progfun1. It looks like some topics were thrown away. E.g. quick check assignment is not in a right place. Assignment about Streams is too complicated and does not illustrate streams well. There is not enough information about design - e.g. more patterns and guidance when to use mutable state with oop princilpes and when to use fp.

Weird mix of disorganized materials. Manner of teaching of Erik Meijer is really annoying. Course "Functional Programming Principles in Scala" was much better

Good course but not much coherence between lessons and exercises.

progfun and reactive programming was better

I was expecting more from it.

I was expecting this course to be more challenging than Functional Programming Principles in Scala but found this one easier in the end. The assignments were ok but I felt like they could have been more challenging and also that they should have tested my understanding of the course contents more thoroughly.

This course was a bit of a mixed bag - some great bits and some really badly designed bits!

Seems it was originally two courses which have been mashed together, and the joins are pretty rough...

First week on Streams/Lazy Lists was great, but seemed to actually have originally been the final week of the functional programming principles course.

The circuits example was interesting, but could have done with an assignment to bed in the knowledge - the actual assignment had little bearing on this material.

The futures section was interesting, but there appeared to be some missing sections due to the course reorganisation, so it didn't flow especially well. Again, some more concrete examples and an associated assignment would have been appreciated.

Definitely a useful course, but be prepared to put up with the rough edges!

The first week is simply useless :(

The course needs a reboot. Some parts were merged with other and the whole thing lacks continuity. A few examples were poorly chosen. For instance, signals / reactive concepts would be easier to understand in user interfaces or graphics / games.

This course has some really good material but the way it has been presented is very disjointed and does not really do the job of properly illustrating Functional Program Design. Although topics such as Signal and FRP are interesting they serve little value in day to day use and assignments focusing on Futures would be far more beneficial.

Videos from previuos version of the course Reactive programming in Scala makes this course worse prepared. I had impression that it was made rushed from shredded pieces. Assignements are easier than previous

The old version was more interesting.

The lectures were quite interesting, especially the first two weeks and the ones by Erik Meijer. But overall course seems to be too blatantly put from several other courses which might be interesting to listen separately (e.g. FRP) and the assignment don't seem to cover the material from the lectures too well. Some very interesting concepts seem to be left out of the scope (actors)

The course material/presentation gets bit sloppy, particularly the secondary presenter and his slides during week 4 are confusing. And the exercises might ensure that everyone can pass and even might work as reference material for self-study, but it would have been more useful to ask for "ground up, practical implementations", instead of filling in something like five trivial lines of code per assignment. C.f. to the Functional Programming for Scala book, which is a lot more helpful towards understanding some of the concepts being elaborated here. Overall, this course seems to address a too wide audience in too little time.