Chevron Left
Retour à Functional Program Design in Scala

Avis et commentaires pour d'étudiants pour Functional Program Design in Scala par École polytechnique fédérale de Lausanne

3,094 évaluations

À propos du cours

In this course you will learn how to apply the functional programming style in the design of larger Scala applications. You'll get to know important new functional programming concepts, from lazy evaluation to structuring your libraries using monads. We'll work on larger and more involved examples, from state space exploration to random testing to discrete circuit simulators. You’ll also learn some best practices on how to write good Scala code in the real world. Finally, you will learn how to leverage the ability of the compiler to infer values from types. Several parts of this course deal with the question how functional programming interacts with mutable state. We will explore the consequences of combining functions and state. We will also look at purely functional alternatives to mutable state, using infinite data structures or functional reactive programming. Recommended background: You should have at least one year programming experience. Proficiency with Java or C# is ideal, but experience with other languages such as C/C++, Python, Javascript or Ruby is also sufficient. You should have some familiarity with using the command line. This course is intended to be taken after Functional Programming Principles in Scala:

Meilleurs avis


14 sept. 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!


17 mars 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.

Filtrer par :

426 - 450 sur 512 Avis pour Functional Program Design in Scala

par Hitesh

26 nov. 2018

Good Course. Recommended

par Pietro G

2 sept. 2017

Actors were missing.

par Riccardo C

17 avr. 2017

High quality course

par Kyoung-Seop P

6 janv. 2017

Very good! ^^

par Алексей Д

28 janv. 2017

too easy

par Luciano C

16 juin 2017


par Michael J A

18 juin 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.

par Porter J

21 mai 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.

par Isaac L

6 nov. 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.

par Joan S S

26 août 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.

par Leitner C S E S

4 oct. 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.

par James M

1 mars 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.

par P.K

12 avr. 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.

par Agustín B S

9 janv. 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.

par Shkodran G

14 janv. 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.

par Omar E

16 oct. 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.

par Brad H

29 oct. 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.

par Laura W

12 juin 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.

par Juraj

17 févr. 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.

par Carl S

26 mai 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.

par Valerio M

20 sept. 2016

Interesting course. Not sure it really covers functional programming design, it feels more of a brief introduction. The material is clearly a cut & paste from a different (and I guess longer) course. There were references to non-existing weeks, and to subjects that were not part of this course. That felt a bit cheap, considering that courses are not really free anymore. Positive experience, but not exceptional.

par Alexey P

6 sept. 2019

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.

par Shriharsh M

20 avr. 2018

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.

par David B

18 juil. 2017

Decent follow up to the excellent first course. There are three programming assignments, all quite challenging and interesting. The second assignment followed a series of lectures on mutable states. However the assignment was all about Scalacheck which was not at all covered in the lectures. Strange. If you're unfamiliar with reactive programming (as I was) the material will be challenging.

par Rudolf Z

9 août 2017

This course introduces many important concepts in functional programming such as monads and lazy evaluation. Also you can find quick intodution to reactive programming in this course, however I want to know more about reactive programming. Week 4 is bad structed, it looks as if it was cutted from another course and pasted in this one. And I want more assignments to play with monads.