Chevron Left
Zurück zu Functional Programming Principles in Scala

Kursteilnehmer-Bewertung und -Feedback für Functional Programming Principles in Scala von École Polytechnique Fédérale de Lausanne

4.8
Sterne
7,193 Bewertungen
1,438 Bewertungen

Über den Kurs

Functional programming is becoming increasingly widespread in industry. This trend is driven by the adoption of Scala as the main programming language for many applications. Scala fuses functional and object-oriented programming in a practical package. It interoperates seamlessly with both Java and Javascript. Scala is the implementation language of many important frameworks, including Apache Spark, Kafka, and Akka. It provides the core infrastructure for sites such as Twitter, Tumblr and also Coursera. In this course you will discover the elements of the functional programming style and learn how to apply them usefully in your daily programming tasks. You will also develop a solid foundation for reasoning about functional programs, by touching upon proofs of invariants and the tracing of execution symbolically. The course is hands on; most units introduce short programs that serve as illustrations of important concepts and invite you to play with them, modifying and improving them. The course is complemented by a series programming projects as homework assignments. 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 using the command line....

Top-Bewertungen

AJ

Sep 24, 2019

As expected Martin is awesome in explaining principle of functional programming. I have started reading the book as well to make sure I keep up with the knowledge which I have gained from this course.

RS

Oct 09, 2016

Really good explanation by the instructor. Good assignments. The assignments gave a good insights into functional programming. I loved the way the problems were decomposed into neat smaller functions.

Filtern nach:

51 - 75 von 1,378 Bewertungen für Functional Programming Principles in Scala

von Vishal R L

Jun 28, 2017

Examples are too hard

von Mironescu M

Feb 19, 2018

very hard

von dd3334

Jun 27, 2018

全程念ppt

von Rob G

Dec 17, 2018

I found the content to be too theoretical for an introductory course in Scala.

von Guy B

May 03, 2019

The course is not clear at all

von Jeffrey K

Mar 27, 2017

Not very practical.

von Luis S

Feb 28, 2019

Poorly made.

von Fridrik M J

Jun 21, 2016

I've been developing in imperative languages for the past 10 years, and my motivation for taking this course was to make sure that I was using the functional capabilities of the language.

While I've embraced immutability and higher-order functions since I started writing Scala, I haven't solved significant programming challenges using functional thinking. Much of what I've already done with Scala so far has been relatively stateless request-response communication between systems, and the challenges so far tend to be on the architecture end.

This first course taught me useful things that I hadn't encountered in my industry use of Scala. It has given me greater appreciation for the design of the language and the problems that Scala can solve elegantly. I've also acquired more interest in learning about more functional approaches to various problems -- perhaps I'll dig deeper into SICP at some point!

The assignments were a good fit for me -- they were challenging enough that they got me to think but not so hard that I got stuck. Scala's rich type system came in handy for the assignments -- once you've got the right idea for an approach, you just have to get the data structures to click (with some help from the compiler), and things just work!

I appreciate that the assignments and examples were realistic. Getting to implement Huffman Coding and basic data structures (functional and OO sets) helped me both appreciate the functional way to solve problems like these, and to understand the class of practical problems where similar solutions are applicable.

Great course, and I'm excited for the next ones! Thanks to Martin and the course staff for their hard work on the course!

von Samir S

May 25, 2020

I have been programming in Java over the past few years. So, when I first encountered Scala code at work earlier this year, I was under the impression that I could just go through other developer's code in my project codebase and learn the basics of Scala. However, as weeks went by, I realized that I knew only bits and pieces of the language; and often, I was left scratching my head in bewilderment at some of the functional style code that I came across very frequently. This was when I decided to enroll in this course, and I think it was one of the best decisions I made. Professor Martin Odersky covers the concepts of Scala and Functional Programming so well, with all the in-depth examples. However, the real icing on the cake is the assignment every week. I really had fun completing all the course work and I can safely say that I have learnt much more than I could have by just going through bits and pieces of other developer's code in a Scala codebase, in the same amount of time.

von Philip L

Sep 04, 2016

Tremendous course.

Explanations can be terse at times, especially after going over quizzes (where you may only follow what is going along if you successfully solved the quiz, otherwise you may miss important insight), but on the whole, lectures are very strong and help you gain a working understanding of functional programming.

The assignments are carefully crafted and really give you an opportunity to try the stuff from the lecture. Definitely felt like I learned a lot during the assignments.

I found that the last two assignments took more than the recommended 3 hours (closer to 5-6 for me), so plan accordingly.

Personally, I found that this course is even better if you read through the first 4 chapters of Functional Programming in Scala (https://www.manning.com/books/functional-programming-in-scala) before doing this course. By getting two separate, excellent explanations for the same topics, I was able to understand the material much better than just from one.

von Christopher K

Dec 13, 2016

This is an excellent course and a great introduction to functional programming and Scala. If this is the first time you come across functional programming concepts and practices prepare for some frustrating times ahead … but don’t get discouraged it happens to everybody. This is not the kind of course that you can rush through and get a 100%, it needs your attention and some thoughtful effort. Needless to say, if you persist till the end the rewards are plenty, and by the time you complete the course you ‘ll have a feeling of real accomplishment and satisfaction.

Prof. Odersky is an excellent teacher and the material is well organized and presented (probably because a version of the course is offered at EPFL as well).

If you are interested in programming/programming languages don’t miss this one out!! It’s a course that is well worth your time.

von Jong H S

Aug 21, 2017

It's really a privilege to learn from the master Professor Odersky. This is a wonderful and relevant course. My most sincere appreciation to Professor Oderskey who has gone great length to impart knowledge of Scala to the masses. This course, together with 2 other courses in the series have removed all doubts and skepticism I have on when and how to use Scala in Data Science, what kind of problems that I can solve using this language and so forth. This course is truly effective and of the highest quality in every aspect: delivery, content and assignments. In other words, it is of Rolex quality. I will surely recommend this course to anyone interested to get started with Scala or even seasoned programmers. Kudos to Professor Odersky and team.

von Endre P

Aug 30, 2018

Really good course to learn the basics of Scala (well). I always thought Scala is simply a better Java, and read a book that followed exactly this approach, since I am an experienced Java developer. However, after taking Martin Odersky's course, I realised his approach to teaching Scala, namely considering it as a completely new language rather than an improved Java makes it much easier to master the language for those who are already experienced in Java or C#. Prof. Odersky is really good at explaining, and leaves no loose ends in the material, which is rare in todays MOOCs. The assignments are also complementing the theory well enough, and makes you practice all that you have learned from the videos. All in all, a great online course.

von Mumtaz

Jun 03, 2019

This is my very first course on Coursera and thanks to their scholarship Program which make me enable to learning from world top faculty in the field of Computer Science. It is like a dream comes true and you will surely feel like you are physically taking the lecture at EPCL ( École polytechnique fédérale de Lausanne / Swiss Federal Institute of Technology Lausanne). I would highly recommend this course even if you know nothing about functional programming like me. Keep in mind that the instructor of this course is the designer of the Scala language and who would be the best teacher other than the designer itself. Additionally, EPCL is world's top 22 and 8 in general and computer science subject ranking by QS Top Universities 2019.

von Ian E

Dec 07, 2016

An excellent course but tough! It has to be the number one way to be introduced to Scala. I spent a lot of time absorbing the material given in the lectures; the material is pitched just right to keep you thinking but yet not lose you. And the language is big, so there is a lot to cover, but I expect the greater expressiveness of the language to make developing software ultimately easier. I have an OOP background and had just played with LISP and Racket before, so though recursive programming was not entirely new, I found the assignments very demanding. But with perseverance they are doable and you are rewarded with satisfyingly elegant solutions. Verdict: highly recommended.

von Garth J M

Mar 06, 2018

Very good course. Real brain teaser for one experienced in imperative programming. When I thought their tests were mistaken, a little reflection taught me new principles and I found that it was I who was in error. As one who has taught and loves to teach, I think the design of this course is excellent. I especially liked the pause in the lecture where a problem was presented which I could copy and paste into a worksheet and solve. Sometimes my first efforts were fruitless and I was totally clueless but without a dent from experience, a new concept often has no place to go. When you experience a lack, your mind and heart are ready for the solution. Good way to teach!

von Ty B

Jun 26, 2016

I use a lot of Java in my current job, but recently had a chance to dip my toes into Scala for a recent project. I liked it so much, I decided to take this course to get a little more knowledge of the language.

I have to say, I don't think you can get much better of a teacher for an intro to Scala course than the designer of the language itself. The course was easy to follow, featured relevant assignments, and was quite useful. At one point, Odersky mentions basing the course partially off of SICP and that seemed apropos -- the course was sort of a condensed, Scala-based version of SICP.

I'm definitely looking forward to taking the next course in the series.

von Roland F

Jul 22, 2017

This is easily one of the best courses on Coursera. Martin Odersky explains concepts very clearly, motivates them well, and teaches at a level suitable for newcomers. He manages to effectively teach principles of functional programming while also introducing the Scala programming language. Exercises are challenging and require creative thinking that enable them to often be solved in multiple ways, and are very rewarding. I think that taking this course has made me more aware of good programming practices and thus helped me become a better programmer. Would highly recommend for anyone studying computer science or software engineering.

von Sergio L

Jun 25, 2017

Very good introduction to Scala and functional programming. Some of the exercises are quite challenging and i can imagine that the lectures would be difficult for someone who has never done functional programming before. I think it would be better that when a new concept is explained, it should be explained with a simple example. That way, the learner can focus on learning the new concept in isolation. Sometimes, a new concept is introduced in the context of a difficult or mathematical problem. This means that the learner needs to understand the problem domain as well as the new concept. This is the case in the exercises and the lectures.

von Charles A

Dec 17, 2019

Amazing opportunity to see Scala from the perspective of its author. The explanations and topic sequence are really good. The examples and assignments are quite deep. I learned a lot about FP and the beauty of Scala syntax/constructs. The platform is really good. I will definitely do more Coursera courses. In a few places there's more maths than I expected (but it isn't necessary if you aren't interested). The getting started material is a little dated; I expect most people are using IntelliJ - it's very important to "import" the sample projects (not open them). Sometimes I found the guidance more confusing than the problems.

von Joshua S

Oct 10, 2018

A wonderful course taught by Martin Odersky (Scala's designer.) The lectures are both meticulously crafted and thoroughly engaging. Odersky is that rare professor that's not only an expert but an exceptionally good teacher with a passion for the subject. Don't skip the optional lectures, every video is filled with gems. If you really want to know functional programming (for that matter, if you really want to know object orient programming) this course is for you. I've been a software engineer for more than 10 years, and I can't believe how much I am learning from this course, including subjects that I thought I already knew.

von Santiago A A

May 16, 2019

This course was very useful for learning Scala the right way. Everything is perfect but, even for people as me with experience in big data, functional programming, and discrete mathematics, it was difficult to follow up on some exercises, especially understanding recursivity with set combinations or with 'for's with two variables(i,j). However, these very hard exercises were few. The other exercises are just hard, and there is not an easy exercise.

This is an advanced course for people with solid bases on discrete mathematics, data structures, algorithms, software engineering, compilers, and operating systems.

von Niina S

Jun 05, 2017

The videos were a great way of learning: seeing and hearing the way Odersky thinks was mind-opening. I'm an aural person, so video is some 300% more efficient to me than just slides/pure text based web pages. Also the point were the video stopped and the student was really put to use his/her own brain was an excellent idea.

Some of the exercises were too difficult for me. Luckily I have a person I can consult if I'm stuck too long with the same problem. (He didn't write the answers, just gave me some hints with pseudo code.)

Recursion has always been hard for me. I'm sure it got better with this course.

von Fernando G M

Jun 25, 2017

I'm a java developer and I'm interested on Big Data projects because of that I decided to learn a functional language, I choose scala because it runs on the JVM, because there is plenty of info about, but the main reason was because I found this awesome course given by the creator of the language. The course is easy to understand and it invites you to do additional research thru the recommended material, the book "Structure and interpretation of computer programs" helped me a lot. The exercises from week 4 and 6 are tough, and I like that, but definitely additional guidance would be of great help.

von Glenn H L

Feb 13, 2020

The programming assignments are tough, but thinking at different levels while working hard to reach higher levels of thinking makes us tougher. For each assignment I open, I somewhat die inside. And then try to do it. It's both a blessing and a curse. It's a blessing because we actually become tougher engineers who could think in pure functions. It's a curse because you wrack your brain so much that it hurts and it gets blank, and then check the clock only to find out it's only been 3 hours since you started an assignment. It gets a little bit easier with each successful writing of a function.