everything was intuitive and enjoyable

The last week's lectures are hard to grasp, but everything else is excellent!

One of the very top courses on Coursera. Prof. Martin Odersky, is truly incredible !

nice

Challenging and rewarding

Cool stuff

This is a great course with a clear exposition of some of the more complex topics in FP such as Monads. However, I feel the treatment of concurrency left me with more questions than answers (though I also understand the next course will explore it in more detail). I would have also liked some more excercises about building a Scala program "from scratch".

Very interesting course. You can learn the basics about functional reactive programming and get to know about Signals and Futures. The assignments are not as difficult as the ones in the previous course and you can see that there is a lot of work to provide the infrastructure needed for those exercises.

It would be nice to have the missing lectures too!

It is a really nice course but a bit dated.

This course felt a bit less fundamental than the Functional Programming Principles but offered some nice introduction to more advanced concepts that feel to bridge the gap between theoretical advantages and real-world use cases.

On the other hand the Monad concept which I often hear about still feels a bit fuzzy, I felt like less time was dedicated to theory in this course.

This time again the exercises are challenging but fun and above all really help internalizing the concepts, although it feels like it will take me more work to really grok Signals not to mention Future which are not used in any exercises.

Better than the first part!

Provides an interesting theoretical bird view on: monads & its relation to for expressions, streams & lazy evaluation, elegant examples of mixing mutable and immutable data-structures for stateful programs, and finally signals for event management. The exercises are fun ;-) and illustrative although not too challenging.

There were some discontinuity in the last week. The classes appear not to be from the same planning, and the teachers say about classes that are not in the course. It should be revised.

Challenging assignments, nice lectures except those prepared by Erik (quite boring)

There's a lot to chew on here, and it's well-articulated. Some of the examples are a bit opaque and academic - a little more of a practical, intuitive approach would go a long way.

there are a lil bit disordered of the course arrangement

the last few weeks are a bit sloppy. hope can improve

Video material is a little bit confusing. It reminds me patchwork quilt

内容不错，但老师的教学方式太差了，就知道读PPT，害得我睡着好几次

The last star is missing because it's not in depth enough

A good introduction to design of more complex Scala programs in a functional manner.

Left a few things to be desired some places, such as: less legacy from the previous "reactive programming in scala" course; a discussion of immutable options for functional reactive programming; and a demonstration of an implicits-based implementation of Functional Reactive Programming, as was mentioned.

For the most part a great course though.

Good course, wish is expanded more on Functional Program Design.

This was my first experience with Functional Programming and also Scala. I found many parts of the course challenging, but also so much fun to me.

During the course, the teacher talks about the Scala development techniques, but also fundamental implementation of Scala language. I think the course will be more informative if the two kinds are clearly separated, since people would have different motivations towards the course. Many people may not need to understand what is going on behind the abstract functionality for their practice, but knowing them will push them up to higher levels.

I myself wanted to focus on getting used to coding with Scala, even if I am not 100% sure how the things are going on behind scene. Fundamental topics will be of my interest once I become a intermediate developer of the language.

I feel that the lectures need more detailed discussions about the scala design pattern.