This course wasn't so good as I expected. Martin Odersky is a good scientist, but his teaching experience isn't so brilliant.
There are a lot of useful topics in the course, but their explanation isn't clear in many cases. Also examples are too academic =(
The course is not bad per se with an in-depth introduction of the concept and practice of functional programming.
However, the course is not for a starter programmer or someone wish to study Scala from zero - as it is a introduction of functional programming concept which presume you have some basic knowledge of Scala.
You might have a hard time if you are not familiar with Scala, especially at the beginning of the course.
I just completed this course -- I was curious about FP but had no previous FP
The course was well organised. The videos had a good pace, good content and
were good quality. The weekly assignments put into practice what I had just
learned in the videos and I had to think hard to solve the assignments.
The software installation and automated submission and marking of assignments
worked for me without any problems.
The discussion forum was active. It seemed like a lot of people were taking
The only negatives were that I found about 10% of course to be theoretical
(Induction proof) and not really of practical use, and I spent about 10 hours
per week on the course, not the estimated 5-7 hours (mostly because the
assignments were difficult).
The best class I have taken on programming. This course does demand a lot of
work from you but it opens up you to new way to think about programming. I had
significant professional development experience in Java, but that didn't make
it any easier.
I had experience on Functional Programming. The course is excellent, awesome.
You learn the basis of Functional Programming in a JVM based language like
Scala. The lessons are excellent prepared. The teacher is the creator of
Language. The assignments are difficult but it's worth to take efford to
resolve them .
I took this course because it is a recommended background for the course
"Principles of Reactive Programming".
In this course Martin Odersky show off the functional elements of Scala.
If you want to learn functional programming then " Introduction to systematic
program design - part 1" is much better.
If you want to lean Scala the this course is not extensive enough.
If you are wondering how the functional paradigm is expressed in Scala then
this course is the answer.
The programming assignment was quiet easy when you have the systematic program
All in All I didn't learn much in this course something got clarified and I
got to see another language.
The course is okay made and a more junior programmer might find it useful.
I am a software developer with a lot of experience with Java, C, C++, assembly
but little with functional programming. I have started about 12 online courses
on Coursera, edX and Udacity and completed 8 of them. I have to say that the
scala course is the best I followed. Prof. Martin Odersky is may be not the
best teacher I met, compared to Walter Lewin at MIT or Jim Fowler at Ohio
State University, but the functional programming is a delightful subject and
the assignments are fantastic. The course is moderately difficult if you have
experience in Object Oriented Programming et probably very easy if you have
functional programming experience.
Very good and complete course about Scala taught by its creator, which adds
value to it. The first time i started the course I didn't have much time and
no prior experience in functional programming, so the first assignments seemed
a bit tough, when I had more time and experience (at least about the basic
functional paradigms like map, fold, reduce) everything was easier. By the way
I suggest everyone to take this course, even without previous functional
experience but with a bit of additional time.
Had some contact with Scheme has a 1st programming language. I can't recall
anything which could be corrected on this course, together with MITx's 100x
it's the most flawless MOOC offering I've ever experienced. -Fun assignments
-Unconventional yet relevant subject -Teaches a new way of thinking rather
than just a new technical skill -Very competent and eager to teach staff (both
Prof. Odersky and the TAs) -An optional formal approach to FP
I haven't had a lot of exposure to Functional Programming before taking this
course so even though I got a score above 95% I found it challenging at times.
It teaches you FP concepts pretty well but the difficulty curve is pretty
steep. What I liked about this course is how the assignments were graded -
fully automatic! Pretty impressive. Course by the Scala author, highly
Just didn't work for me: Odesky gets on my nerves and fails to motivate me to
learn Scala, which just does not seem elegant. BTW. I am familiar with 3
(other) functional programming languages, not including their dialects.
Compared with Programming Languages offered by the University of Washington,
I'd say the lectures could have been longer: I had to do some extra reading
/forum searching to finish the assignments. Still, it's a quite decent
introduction to functional programming, especially as its workload is
significantly lower than the above-mentioned course(still takes half a day to
finish at least, mind you), and therefore more reasonable for people who have
other commitments in life. Another benefit is it teaches in Scala, which, as
of my knowledge, is rarely covered in real undergraduate courses. That is to
say, if I want to take a Programming Languages course I can still do it in my
school, but Scala, no.
Very interesting and easy to follow ( for people with programming background)
course from father of Scala language. Lectures are very clear and interesting,
programming assignments are reasonably challenging. I can recommend this
course to anyone, interesting in functional programming, Scala language (or
both) topics. This course is also prerequest for "Principles of Reactive
Programming" course. One advice for future students - don't undervalue forum!
In particular in forum there are FAQs, built on base of questions of previous
students. Those FAQs can save your time (and even some grading points).
I am BSc in Computer Science and MSc in Information Management with some
working experience as a Software Engineer for Fortune-100 companies. The
course is EXTREMELY useful both in practice (I mean writing real-life
production code) and (which could be even more important) during the
interviews. I highly recommend to attend it for anyone planning a career in IT
and can't wait to take its second part.
Very nice course by Professor Martin Odersky the creator of Scala. Nice topics
covered considering it's an introductory course in functionnal programming. So
not every aspects of the scala languages are covered (mutable state,
concurrent programming, etc.)... The homeworks were not so hard. I'm looking
forward for the follow up class : Principles of Reactive Programming.
I'm still doing the course and may update the review but I thought I'd discuss
my current experience. Overall I'd recommend the course. Its a good
introduction to Scala, has some interesting coverage of functional
programming, and is generally quite enjoyable. My only gripe is it doesn't
have as much in depth coverage of functional programming as I'd have liked.
The assignments do force you to think of how to decompose, analyse, visualise
and test functional solutions but there isn't actually much coverage of those
aspects in the videos. This seemed to be a common complain in the forums too
so I don't think it was just me. Other than that though its great.
This was an excellent introductory course in functional programming. It also
served as a great introduction to the Scala language - taught by no less than
the language's creator. Awesome! It isn't, and doesn't purport to be, a
general introduction to programming. You should have a little experience
programming before tackling this course, though by no means do you need to be
an intermediate programmer, much less an expert. The grade is determined
solely from the programming exercises. The exercises themselves are quite
easy, but encourage you to think in the "functional style," which, coupled
with the unfamiliarity of the Scala language, may make them initially a bit
more challenging until you get comfortable with the idioms and syntax. For
experienced developers, even those with limited functional language knowledge,
it likely won't require more than 2-4 hours/week, particularly if you view the
videos at double speed... but please slow down if you're not absorbing all the
concepts - there are some great ideas presented, and they provide a large part
of the value of taking the course! For novice programmers, it may require a
bit more time to complete the programming exercises - the forums can provide
assistance in this regard. In particular, I'd emphasize to those new to
programming that they should take Professor Odersky's recommendation and read
the book "The Structure and Interpretation of Computer Programs." Some of the
exercises are adapted from this classic text, and it can provide a richer
understanding of the course material than the videos alone.
Very good course. This is the first course I took on coursera connected to
computer science which doesn't use standard coursera's quizzes. Instead it
evaluates your code by tests, and checking style rules. It works very good.
There are no quizzes nor exam about lectures, only programming assignments.
Assignments themselves are good planned. They help show both basic language
features, and basics of fuctional programming. They start from very easy
level, and gradually the difficulty rises. It shouldn't be too difficult to
get passing grade, but you need some work to get best mark. Discussion forum,
and course help is organized nicely. Staff is responsive to feedback of
students. The weakest point of course are the lectures. They aren't bad, but
their pacing could be a little faster (watching at higher speed helps), and I
think that some (not that difficult) topics were explained too deeply. Because
of lectures I can't give full 5 star rating, but it's really close. Just be
sure that you pass per-requirements of course, since it is assumed that you
have some experience in programming.
Great course - the programming assignments were both challenging and obviously
some thought was put into them, as they each developed key concepts, and let
the student gain knowledge of the subject area gradually. The video lectures
were very well done too, no flab or off-topic stuff, just what you need to
Amazing course, great teaching stuff. The pace is good for a MOCC. I learned
the principles of functional programming. See the promising future for
functional programming. Looking forward to taking more advanced
Scala/Functional Programming course from Martin's team. Thanks a lot!
I had no expirience with Scala until this course. Course is greate! A lot of
practice without theoretical questions, as I like. Homeworks realy make my
brain work harder and in different maner. I think is realy cool when creator
of the language find some time to teach other programmers for free. Thanks!
This was a challenging but inspiring course. I had some background in
Functional Programming as a hobbyist - I got so far as writing a Minesweeper
clone in Haskell once - but no experience with Scala. I was impressed with how
easily the functional concepts merged with the OO-concepts from Java in Scala,
and I think I gained new appreciation of both. The course was hard, though. If
I hadn't heard about FP at all, I doubt I would have managed to complete it,
and you would absolutely need confidence doing programming exercises. The
deadlines were reasonably generous for Coursera, but still it got tight
towards the end. There are no comparable courses on Coursera or any other site
that I know of, but I would definitively take a followup course if Odersky
Taking a class about Scala from Martin Odersky is like getting to take a class
on Python from Guido van Rossum, or a class on Perl from Larry Wall. If you
like to learn new programming languages, you should not miss this class! (This
is NOT an introductory programming class, and would not be appropriate for a
novice programmer.) The assignments are clear but challenging, and you're
provided with unit tests, so you'll know whether your code works before you
submit it. The assignments for the last two weeks are rather time-consuming.
My only complaint about this class is that the Scala plugin for Eclipse, which
you are required to use, was a bit buggy, but perhaps they've ironed out these
issues since I took the class in the Fall of 2012.
This is a brilliant course. Scala is a very terse language that borrows from a
number of other languages and runs on the JVM. Scala is written to support
programming in both imperative and functional style. The course emphasizes
Sacla's functional programming features. Functional programming differs from
other styles of programming in that programs don't maintain "state" - the use
of traditional programming constructs like variables, iteration and mutable
data are discouraged. Instead, all functions are "first class objects" and can
be passed as parameters to other functions. Programs become recursive,
stateless function calls. This takes some getting used to for an old Java guy
like myself. It is fascinating and a little frustrating to look at the world
in a new way. I can well imagine that functional-style programs might be
better for many classes of problems than imperative-style approaches (OO in
particular). But the real draw for me was just the excitement of looking at
very familiar tasks in the light of very unfamiliar techniques. I was
expecting to learn about Scala. It turns out that Scala is not so difficult. I
really learned about FP. If Dan Grossman's Coursera course on Programming
languages had been available, it would have been helpful to take that first,
although both courses stand alone, and functional programming is a large
enough subject that more than one course is not excessive. I loved the course
and can't recommend it highly enough. You ought to be an experienced
programmer or expect to have to work very hard to keep up.
This course was a great way to learn Scala. Although I had some contact with
functional programming before, this course helped me to refresh that knowledge
and better understand functional programming concepts, which are proving very
useful on my work as a software developer.
Rankings are based on a provider's overall CourseTalk score, which takes into account both average rating and number of ratings. Stars round to the nearest half.
École polytechnique fédérale de Lausanne
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.
Learning Outcomes. By the end of this course you will be able to:
- understand the principles of functional programming,
- write purely functional programs, using recursion,
pattern matching, and higher-order functions,
- combine functional programming with objects and classes,
- design immutable data structures,
- reason about properties of functions,
- understand generic types for functional programs