Sep 15, 2016
This is a university degree course which takes enormous effort to complete. But still its beond the programming course range giving you whats not possible to google or learn practical way. Thanks!
Mar 18, 2018
Thank you for this exciting course! I did the FP in Scala course a few years ago and decided to do the full certification now. I am looking forward to the next courses in the specialisation.
by Damon Z•
Nov 18, 2018
A little difficult but have fun.
by Shad A•
Oct 31, 2016
Thought provoking exercises.
by Marcin Z•
Mar 24, 2019
Better than the first part!
by Dumitru C•
Jul 01, 2016
Classical in type and value
Nov 26, 2018
Good Course. Recommended
by Pietro G•
Sep 02, 2017
Actors were missing.
by Riccardo C•
Apr 17, 2017
High quality course
by Kyoung-Seop P•
Jan 06, 2017
Very good! ^^
by Aleksey D•
Jan 28, 2017
by LUCIANO V C•
Jun 16, 2017
by Michael J A•
Jun 19, 2016
If you're new to Scala and/or functional programming, then the material covered here will be very valuable.
However, I was fairly disappointed. Much of the coursework was pulled from the original "Functional Programming in Scala" course, as well as the "Principles of Reactive Programming" course. Indeed, there are references to material from those courses that are not actually included here, which must be a little confusing for anyone who hasn't taken those courses. The first two assignments came, respectively, from those two courses also.
There wasn't as much emphasis on architecting a functional program as I might have expected from the title. Instead, the course focused more on using functional principles when implementing computations. The coverage of functional reactive programming (FRP) was very good, but again, I would have expected more of a 30,000ft overview of how to design an application using FRP.
In short, I felt this course to be a little incoherent and disjointed.
by Michael R•
Oct 23, 2019
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!
by Porter J•
May 22, 2017
Martin Odersky's lectures are excellent as always. The first few weeks of material were excellent and very helpful--particularly the coverage of the advantages and disadvantages of mixing mutable state with functional programming. My issue with this course is the the final week's materials are patched together and seemingly incomplete--some of the videos switched to a different lecturer, who was referencing concepts not covered in the course. I was able to figure things out enough to complete the assignments, but based on the exercises in the course I wouldn't feel comfortable implementing functional reactive programming in a production environment--this was a good introduction to the concepts, but the solution in the programming assignments feels very makeshift and is not something I have a lot of trust in.
by Isaac L•
Nov 06, 2016
The content was pretty good, but I'm annoyed that I paid for a disjointed collection of videos that were previously available for free. This is just a pared down (worse) version of an older class, "Principles of Reactive Programming", which I started but didn't finish three years ago. The videos and assignments are the same, but some of them have been removed, so there are confusing discontinuities. Some of the videos refer to a "next lecture" or "previous lecture", which isn't included in this class. The last week of the class should have been split across multiple weeks, and I'm disappointed I never got to do an assignment on latency or futures.
That being said, I'd still recommend taking any class taught by Odersky, and I learned a fair amount.
by Joan S S•
Aug 26, 2016
The subject is really interesting, and some of the shown approaches really "close to the edge".
However, there is too much "cut and paste" from other courses. this makes this one difficult to follow. It has lost "coherence". The cross-references don't make any sense, and the assignments fall too short with regard to the content. I think the remake from the original "Functional Programming ___ in Scala" + "Reactive Programming" has not been as successful as it should. This new format within Coursera (everything shorter, more expensive and with less people involved) is not as good as the original one. Maybe this is the only way they can make enough money to sustain the whole... but the "more idealistic" start was far more pleasant.
by Leitner C S E S•
Oct 04, 2017
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.
by James M•
Mar 01, 2017
Good topics, just poorly structured. I found the exercises easier than the previous module, but the lectures were worse. I ended up watching 1 lecture on week 3 and again on week 4 -- none of the other lecture content was relevant to the exercises. Would have loved a decent explanation of a Monad and their usages, but it really felt out of place in this course (no exercises on Monads).
After completing the first two courses I don't feel like I would bother with the next ones. The course content is far to academic and I would get far more from a book.
Apr 12, 2017
It is a good course. I took it after Functional Programming Principles in Scala. I learned new things....But..... The reason i rate 3 is that:
1) Programminng Assignments doesn't realy correspond to the Lecture material.
2) The Lecture material becomes very complicated in some Lectures because of Lack of Explanation (e.g: Lec 4.3. There are still many disambiguations of how the Prof. creates some models (again lack of explanation)
3) Too many unanswered critical questions remain in the forum!!!
Anyway it's worth your time.
by Agustín B S•
Jan 09, 2017
I have seen reference to the previous second course on the specialization, 'Functional Reactive Programming in Scala', comparatively this one looks much easied down, I am hoping to find the excluded content on the third course. Sessions by Erik surely are a 100% pertinent and consistent within the full syllabus they were conceived for, but inserted here they break a bit the overall discourse, in my view. Got the feeling that the exercises cover only a little part of the theoretical content exposed in the lectures.
by Shkodran G•
Jan 15, 2017
Last week's content was thrown together from various bits & parts from the Functional Reactive Programming in Scala (or whatever the name of the predecessor of this course was).
Overall, I felt that there was a lot of ground covered in a short amount of time - the course would have been better if it was longer, and week 4 material would have benefitted from being stretched into two or three weeks. Rather than reuse parts of the old course it would have been better to have new content purpose built for this course.
by Omar E•
Oct 16, 2017
The course is well structured although it is a bit short. I was expecting to dig deeper into more asynchronous models. A better explanation of Actors would have helped. Also I felt that the exercises were missing the point of the lectures.
The lectures by Erik Meijer felt out of place and poorly connected to the previous content. Similarly, his lectures were tedious to follow. I would have preferred more on-scree time of the slides instead of the shared screen.
by Brad H•
Oct 29, 2017
As a continuation from the previous course, "Function Programming Principles in Scala", I found this less focused -- especially with respect to the title. For instance, at times there did not seem to be a strong match between the programming assignment and the lecture material. Regardless, I still learned quite a bit and Dr. Martin Oderksy is an excellent video presenter. I am still surprised by how powerful Scala can be in a terse yet readable manner.
by Laura W•
Jun 12, 2018
The course was really unstructured. The assignments were too easy and did not cover the material from the course. Several times there were further classes on a certain topic promised, which this course does not include. Week 4 was especially confusing. Concepts were used, which weren't introduced before. The end seemed rather abrupt. Overall the content from this course is really small compared to the previous course of the Scala Specialization.
by JURAJ M•
Feb 17, 2017
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.
by Carl S•
May 26, 2017
The lectures were not very illuminating and did not tie in closely with the programming assignments. There was very little focus on design. This course did nothing to answer the questions of why, if you were building a real-world software product, you should use Scala in particular or functional programming in general. It merely served to provide a few more examples of FP patterns without demonstrating their value.