Very well delivered course, more examples are needed though.

The assignment could be optimized and avoid to be more academic since it may make student lost focus and spend too much time on the question itself rather than the parallel programming

Very good course overall on the basics of parallel programming in scala. Would have been nice to talk a bit more on the low level setup (parallel and task construct code).

Overall the course was really good. I think the first 2 courses explained things a little bit better though.

good overall, but sometimes overly complicated

Some problems with downloads and to view videos on the mobile app (Android), with some videos recorded with a low volume.

Despite that interesting and I think would need more time to get deeper in the concepts showed.

Time to complete exercises might not be completely assessed. Some lectures seem to technical without any correspondence with real problems.

The course is pretty hard, even for someone like me, who has been working in parallel computing for years. The reason is the structure of the course and the presentation of the material. The topics are somewhat chaotic and in many cases it is hard to tell whether a certain operator comes from the Scala standard library or is just an abstraction.

All in all, finishing the course is a rewarding experience. But beware, there is a significant gap between the foundation courses taught by Martin Odersky and this one.

Presentations were presented well and the assignments were interestingly varied but quite challenging for the newbie.

Assignments weren't challenging.

Good explanations, relevant assignments.

But too small, too little graded assignments as for subject. Be better if the assignments has less starter code.

This course had a lot of depth to it, both in the lectures and the programming assignments. The last assignment seemed needlessly complex with not enough focus on the parallel programming aspect. I wish there had been more of a focus on how to actually write the parallel and task constructs which were instead given already implemented without much explanation.

Would be good to introduce more about Scala native solutions like Futures, parallel data structures and best ways of using them on practice, cases and best practices how to work with shared data, avoid deadlocks, how to work best when you have to process large data or when you have massive calculations.

Excellent course. Gives deep enough understanding of parallel programming. Used knowledge immediately to optimize my huge in-mem data structure to reach 50 ms (instead of 300 ms) response time. I'd suggest the following to improve: 1. I'd make "pass" score no less then 90 or even 95%. With 80 only it is possible to PASS having key mistake (e.g. on week4 I haven't created a new combiner, using old one, in combine() operation, and I still got 80 - PASSED) 2. tests in grader are hard to reproduce on local machine: it is not that obvious what's wrong, where to focus.

Assignments are focused on problem-solving rather than the importance of parallelism, missing the point of the lecture. It is a Scala course, so it is always fun!

Some instruction is pretty confusing

It would be great to have some tests for understanding algorithms (like in algorithms course), not only practice programming assignments. Assignments are really interesting but can't verify your understand material or not. Also it is possible to pass assignment event if you have mistakes in the code.

Interesting course but math part is too academic and boring. It'll be more useful if focused only in real use cases.

Good course with a lot of interesting ideas and explanations. The reason I gave it a 4 and not a 5 is that I think it would have been better without involving instructors' own library on top of Scala instead of teaching Scala-level constructs directly. While I appreciate the notion of teaching general parallel programming ideas, introducing one's own constructs to promote it seems unnecessary - at the very least, these constructs' implementation should have been thoroughly explained in the course.

Really cool course. I'm enjoying scala as a language as it has many simple methods to achieve complex goals, including parallelization, however this course also presents parallelism in a rawer fashion explaining in depth some of the techniques to parallelize seemingly sequential-only tasks.

Last week's exercise is quite long, and albeit being a truly beautiful project, most of the implementation is not strictly related to parallel programming.

In any case a totally good course!

Interesting course, but far too short. It ends up giving a quick introduction to some of the aspects of parallel programming. I enjoyed the assignments, apart from last one where the difficulty was more about the context of the example than any parallel programming aspects. That example, extended, could be a good capstone project, but I think it was not appropriate as a course assignment. I prefer courses that follow a book, and this course didn't.

Good course and good level on the assignments but needs a lot of improvement on the lectures, specially in the two last weeks.

Wrongly assumes that it'll be easier for students to jump from the conventional 'parallel' java paradigms and constructs to parallel streams.

Not a good job on explaining why. It'll require from students some efforts to create the right picture in their minds.

Exercises are great and partially make up for the above mentioned shortcomings.

Some example code is very bad and goes against all the 'good' things being taught by Martin in the first course of the specialization.

Too much imperative technics in this "functional" parallel programming course.

For now, the worst course in Specialization.