#15 overallClassic
Programming Languages (Dan Grossman)
Coursera
30 recommenders · 33 threads · recommended in 10 years, 2013–2023 · score 40.8
A Coursera course by Dan Grossman (University of Washington) that teaches programming language fundamentals through Standard ML, Racket, and Ruby, covering functional programming, recursion, types, pattern matching, and language design trade-offs. Commenters describe it as a three-part sequence.
Commenters call it an excellent, well-structured introduction to programming language concepts and functional programming, and several say it changed how they approach learning new languages.
Programming Languagesintermediatefreevideo lectures#programming languages#functional programming#standard ml#racket#ruby#grossman
Recommendations by year
20062026
Adrian is a great guy and I highly recommend all his content.
For undergrad level PL, I highly recommend Dan Grossman's MOOC[0] or recent class recorded lectures[1]. Dan's thesis work strongly influenced Rust's borrow checker.
Disclosure: Dan advised me in undergrad and Adrian is a friend.
[0] https://www.coursera.org/learn/programming-languages
[1] https://courses.cs.washington.edu/courses/cse341/19sp/ (ctrl-f "Videos")
I took the Programming Languages course on Coursera which is so far the best course for me. It changed the way I learn any new programming language.
https://www.coursera.org/learn/programming-languages
I see that they have split the course into 2 parts.
I have only used F# for a couple months, but I have a decent background in ML thanks to the Dan Grossman's incredible programming languages course.
https://www.coursera.org/course/proglang
I would say that if I can use F# Data or Deedle on a project, I will. Those tools totally make it worth learning a little F#.
http://bluemountaincapital.github.io/Deedle/ http://fsharp.github.io/FSharp.Data/
For me Dan Grossman's course on Programming Languages takes the cake. Best course I've ever done. Taught SML, Racket and Ruby enough to touch on so many concepts (FP, recursion, algebraic datatypes, polymorphism,... the list goes on). For the assignments a small programming langauge was implemented in almost all of these, showing different ways of solving the expression problem. It was amazing.
I second that, it's been the best course I've taken up on coursera so far (with Dan Boneh's crypto). The lectures are great, but the best for me was the high quality provided course notes. I read those in my morning and evening commutes and I didn't even have to watch the videos!
The exercises were well crafted, guiding you part by part to build your program, and challenging enough that you learned something valuable. It definitely made me interested in exploring more the three languages presented - ML, Racket and Ruby.
I'm currently taking the second Scala course and I have to say it's a bit of a disappointment so far. Martin Odersky's part was good, but I didn't really like Erik Meijer's teaching style (I understood Futures and Promises better after reading a few articles about these). I haven't caught up with Roland Kuhn's part yet.
However I've been incredibly frustrated with the exercises. They are tedious, but for the wrong reasons: you have to make a lot of guesses on what are exactly the semantics of what you're supposed to implement, sifting through the forum and the FAQ for relevant information. After you've submitted, you now have to wait for a long time (between 20 and 100 minutes) for the automatic grader to tell you whether your guess about what exactly you had to implement was right or wrong.
It's still an interesting course, and it's worth just for the sake of getting your hands into some Scala code, but there's that caveat.
Have a look at this similar course: https://www.coursera.org/learn/programming-languages I enjoyed it quite a bit and the lecturer is fantastic. It also uses SML and teaches similar material, though maybe not as in depth since this is just the first section of a three-part semester long course.
Dan Grossman’s Programming Language series on Coursera is one of the best courses I’ve taken at any level of education
For guitarists, Paul Davids’ courses through his website are excellent
I've completed and can recommend all of these if the topics are of interest to you:
https://www.coursera.org/learn/basic-modeling
https://www.coursera.org/specializations/algorithms
https://www.coursera.org/learn/discrete-optimization
https://www.coursera.org/learn/programming-languages
I'm still working my way through this one but it's been good so far:
https://www.coursera.org/specializations/data-structures-alg...
F#, Elixir, Erlang, Clojure, and Racket is where I would concentrate. Pick one and go for it. Find books that work through a domain in a project-like style and port the code to your language of choice.
Check out the course Programming Languages by Dan Grossman on Coursera.
Reading the textbooks that people use in those classes is pretty helpful.
Dan Grossman has a great set of courses on Coursera, and a good number of resources are in those discussion boards.
https://www.coursera.org/learn/programming-languages
You can also take the course programming languages from the University of Washington on Coursera. The 3 courses use standard ML, racket and ruby to teach concepts a learned programmer should know.
I think Dan Grossman's Programming Languages courses are amazing if you have slept through the subject in university: https://www.coursera.org/learn/programming-languages
I agree that there seem to be a variety of links, but most of the courses linked there are of very high quality and I don't seem to see the "YouTube channels" that you're referring to. One thing I was unsatisfied with with TYCS is how it lists Crafting Compilers for the compilers/PL section of the curriculum. I would argue that more important than the specifics about compilers is a high-level understanding of various ideas in programming language design, and be able to understand the building blocks of different languages and compare the trade-offs of using one language compared with another. Of course, if you go through SICP as an entry point to computing, as suggested in TYCS, then you might be somewhat better off, but it's still not the same as a dedicated course on PL itself.
Dan Grossman from the University of Washington has an excellent course Programming Languages on Coursera: https://www.coursera.org/learn/programming-languages/, which I think would be far more relevant to modern programmers than studying compilers specifically. And I'm glad to see this course listed under the "Core Programming" section of OSSU.
The recommendation of "Crafting Interpreters" is pretty weird. I would argue that more important than the specifics about compilers is a high-level understanding of various ideas in programming language design, and be able to understand the building blocks of different languages and compare the trade-offs of using one language compared with another. Dan Grossman from the University of Washington has an excellent course Programming Languages on Coursera: https://www.coursera.org/learn/programming-languages/, which I think would be far more relevant to modern programmers than studying compilers specifically.
as others have said, the little schemer (for functions) and also the little mler (for types) are purpose built to thinking about functions and types recursively.
also, the coursera course programming languages by dan grossman is an excellent course on doing things recursively. in part a, you learn sml, and in part b, you learn racket and build a simple interpreter.
https://www.coursera.org/learn/programming-languages
https://www.coursera.org/learn/programming-languages-part-b
Wren is a great little language in the Lua sector, but more traditional than it (or JavaScript). Use it with the recently announced DOME to get started with some simple games (People, please don't let beginners start with webdev!)
http://wren.io/
https://domeengine.com/
Having said bad things against JavaScript, I believe TypeScript might be a good start. Definitely a large community support and good tooling.
The problem with either of those is that you don't just need a decent language, you need decent teaching materials. And there's little of that that I'm aware of -- and Rust/Swift/Go aren't even intended for first time programmers (Although the Go Programming Language book might serve well enough, after all we got quite a few people who started with C, a language equally unsuitable for the beginner)
Pharo is a bit too "old", with 12 years (or 24, or 48, depending on how you count), but the environment has a neat little tutorial, and "Pharo by example" is a good book.
https://books.pharo.org/pharo-by-example/
Personally, I'd recommend older stuff/languages. Do the Coursera SML course and you're way more ready for the hot new trends like Elm or ReasonML than your fellow Java/C#/C++ grognards.
https://www.coursera.org/learn/programming-languages
Ocaml decided to be on the "large" while sml kept small it seems. I loved that trait (through Dan Grossman's MOOC). To the point that I found it even nicer to interact with than lisp.
Not GP, but: I recommend Standard ML. I can't see a better way to do this than to power through Dan Grossman's three course sequence, which goes back to the drawing board and teaches Standard ML [0] to introduce modern programming language features such as scope, closures, types, pattern matching, modules, and so on. Then, he uses the concepts introduced in Standard ML as a springboard to introduce Scheme in the second course, and Ruby in the third course. And in the end, you will see how each of the three languages implement in different ways the same powerful techniques.
But with just that first Standard ML course, you can already branch out to more popular languages such as Scala [1], which gives you the closest thing I've seen to "Standard ML on the JVM". But Standard ML (or Ocaml, which is very close) might even be your preferred language for prototyping [2], or compiler writing [3].
P.S.: To make Coursera tolerable, I usually pull the entire course with this nice little script [4]. Works great with ranger and mplayer!
[0] https://www.coursera.org/learn/programming-languages
[1] https://www.coursera.org/specializations/scala
[2] https://sanderspies.github.io/slides/dawn-of-reason.pdf
[3] http://flint.cs.yale.edu/cs421/case-for-ml.html
[4] https://pypi.org/project/coursera-dl/
I'd like to disagree with the title of this blog post.
I did something like this in 2016, learnt Clojure, OCaml, Haskell, Go and Racket. Took Dan Grossman's excellent Coursera course on learning language fundamentals and paradigms across Ruby/ML/Racket. Though I can code basic to medium level toy programs in all these languages now I wish I had followed Dave Thomas' (of Pragmatic Programmer fame) advice of concentrating on only one language a year.
My advice would be pick only one language for 2017 and then think and code only in that language for the year (for your learning projects - of course you'll be using other language for your $DAY_JOB).
In 5 years you'll know how to use 5 tools really really well and your brain will be much better aware of which of these tools is the right tool for which kinds of problems.
That's one of the reasons I loved the "programming languages" course on coursera[0]. The course went through 3 languages, ML, Racket and Ruby giving 2 weeks to each language. And then spent time contrasting the weaknesses and strengths of the different languages and their paradigms.
[0]https://www.coursera.org/learn/programming-languages (Starts up again on the 9th of January :) )
I've been taking a PLT[0] class in school and while the list above is extremely comprehensive and thorough, I'd argue that you do not need to read up all of it to get a good idea of programming languages.
Without even learning all the theory, you can get pretty far ahead (IMHO) in a building your own programming language (if that's the goal). The two resources that I've found invaluable are - the prog lang course[1] by Dan Grossman and PLAI[2] by Shriram. Lastly, there's also a whole bunch of interesting university courses that you can refer to - https://github.com/prakhar1989/awesome-courses#programming-l...
[0] - http://www.cs.columbia.edu/~sedwards/classes/2016/4115-sprin...
[1] - https://www.coursera.org/course/proglang
[2] - http://cs.brown.edu/courses/cs173/2012/book/
I've enjoyed the following resources:
SICP - http://mitpress.mit.edu/sicp/
HTDP - http://htdp.org/
Dan Grossman's Programming Languages Coursera course - https://www.coursera.org/course/proglang
The Racket docs - http://docs.racket-lang.org/
Chris Jester-Young's StackOverflow answers - http://stackoverflow.com/search?q=user:13+[racket]
This list won't be as useful to you as it was to me, because you already know Common Lisp, but hopefully other readers will find it interesting.
NB - the ProgLang Coursera course features Racket alongside SML, Ruby and quite a lot of material that will seem very basic to experienced programmers, but it's a really good introduction of some of its key features. I think this is probably my weakest recommendation to someone who already knows Common Lisp (or similar) and my strongest recommendation to someone who does not.
Beyond that, the default DrRacket IDE comes with a whole load of teaching resources bundled by default, including (iirc) resources to help build a game in Racket - this package I think http://docs.racket-lang.org/teachpack/2htdpuniverse.html.
As for differences/advantages of Racket, I would say that there are few that I'm aware of beyond the simplicity of learning the language, the great tools, and the ease with which you can get up and running. Nothing inherent to the language that I'm aware of, and I would suspect that Common Lisp is great if you're already part of that community and 'know where everything is' so-to-speak. I've heard that CLOS is better than Racket's OOP abilities.
I really do love the language, though, it's one of the easiest and most joyful experiences I've ever had with a programming language. Just maybe not a necessity if you already know CL.
One approach to getting a list of topics is to look at the degree requirements for a couple of universities. I'm wrapping up a similar project, and here's what I included, along with some resources I used:
* Algorithms (CLRS, Skiena)
* Databases (db-class.org, any text by C.J. Date)
* Probability, Statistics, and Combinatorics
* Programming Languages (I liked Grossman's course on Coursera)
* Linear Algebra (http://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebr...)
* Natural Language Processing (Coursera has several courses)
* Machine Learning/Information Retrieval/Data Mining (I used a couple books, Mining Massive Datasets and Data-Intensive Text Processing with MapReduce being the two I'd recommend)
* Networking (Coursera has a good course)
* Operating Systems (https://www.youtube.com/watch?v=XgQo4JkN4Bw&list=PL62A66DDD3...)
* Distributed Systems (I read Tanenbaum's book)
* Computability
I took this class two years ago and loved it. Of all the instructors of the Coursera classes I have taken, Dan Grossman is easily the most interesting and engaging. Highly recommend.
The Programming Languages course on Coursera: highly recommended
I'm a C# guy at work too. I can't say I've touched much C++ outside of college also a while ago, but I've been studying functional programming for a while and really enjoying the new concepts it teaches. It can be a bit humbling at times though.
I got some good perspective with https://www.coursera.org/course/proglang and you could do worse than taking grossman's excellent course. It helps to have some structure and a schedule when starting imho.
I will admit at times I wish I had more chops (closer to the metal i.e. C or C++), but I think I was eventually just more interested in new ways to think about programming, and I'm not sure I'd get the same pleasure out of digging back into C++.
Obviously, if you know something more about your intended use case (i.e. you want to program games), you can make a more informed decision.
I think most of the CS programs will just waste your time --unless you attend to a very good university. Given that best hackers I've met are self-taught programmers, you can definitely work it out yourself. I think these are amazing times; there are many pretty good online courses & materials, places to get help, etc.
I recommend Programming Languages course on Coursera. But if you are impatient, you can start from learning Python (it has a very low learning curve): learnpythonthehardway.org/book/
This is excellent review, no doubt, by a well known scholar.) The only problem is that there are so many books and so little time.
So, to get a quick and productive crash-course I would recommend just a few selected resources.
* SICP based course CS 61A by Brian Harvey (Youtube)
* HtDP2 and a wonderful course based on it - Introduction to Systematic Program Design by Gregor Kiczales (the author of The Art Of Metaobject Protocol)
* Armstrong's thesys armstrong_thesis_2003.pdf and his Programming Erlang book.
* Programming Languages course by Dan Grossman (also on Coursera)
* Two Scala courses Martin Odersky
* The classic Haskell tutorial http://www.haskell.org/tutorial/
* ANSI CL and On Lisp books by pg.
This is a very decent start in my opinion. "To learn quickly read only the best ones".
I enjoyed using Racket in the 'programming languages' coursera course
The Wash U Programming Languages course on Coursera was pretty functional-programming oriented. I really enjoyed it and would recommend it to anyone.
Allow me to suggest Coursera. They have nice courses about FP. Somehow in simple -> difficult order.
Systematic Program Design by Gregor Kicsalez (I believe influenced by HtDP). Programming Languages by Dan Grossman. (50 50 HtDP SICP and Brown University material)* Functional Programming using Scala by Martin Odersky (influenced by SICP).
In case you can already do the SICP exercises without issues then you won't need these, but otherwise, the deadlines and automatic grader were great ways to keep a regular pace in learning.
*) this course focuses on semantics, and language design, the problems are not hard applied problem solving, that's why I put it in 2nd, but they can twist your mind quite a bit when dealing with different meta-levels.
Take this with a grain of salt. There is no right way or the only way.
- Learn complete web development. Use something like CodeAcademy/Udacity to learn the complementary skills you need. My guess is since you know Html/css and Java, you are better off learning Javascript as well. Nodejs / advanced Java might be a good fit.
- Learn some of the theoretical fundamentals. This might not be of immediate need for freelancing, but you should almost always be honing your fundamentals. Take up the core computer science courses on Coursera - Algorithms (1,2), Programming Languages, Basic Math (linear algebra, graph theory etc) are some must haves. This can be a longer term goal and plan it beyond 6 months.
- Sharpen your skills with coding exercises. Do some of the stuff on InterviewStreet and other such sites. Being able to solve small problems effectively and time bound, is very important skills. You should practice hard for the first 6 months I think.
- Know your domain. Being a web freelancer means you might have to be full stack. Being able to write the client and server side with ease. You might want to be good at some specific domains - like building sites for X, Y, Z (you can build your own reusable code). Then expand. Looking at stuff at elance is an easy start.
Its doable in 6 months. IMO don't stop learning.
Snap, me too. It's a great course run by Dan Grossman (who pops up on HN occasionally).
I signed up to learn functional programming and have learnt a lot.
The way is Scheme -> Common Lisp -> Arc.
Scheme comes first because it is more refined and there are excellent courses and books.
CS61A probably the best introductory course. After that it is good to watch original SICP lectures by the two magicians and read the book. Then it is necessary to take a look at what HtDP team is teaching.
After this there will be no trouble with Common Lisp. Classic books are these by pg and Norvig. CLtL is just a reference.
Then, with all the knowledge so far one could understand arc.arc and appreciate what have been done there.)
With this background you will understand what Clojure really is and why, or what is Haskell, and why there is nothing special in it.
btw, there is a brilliant course by Dan Grossman on coursera covering FP. He is very clever and consistent. After this you will smile at Haskell guys.)
Update:
I forgot Emacs Lisp. An Introduction to Programming in Emacs Lisp is an excellent book that covers all the basic principles and gives a perspective how to use lisp in a real-world project.)
I'm having a hard time keeping up with all these awesome classes.
Coursera's PL class is starting in a few days: https://www.coursera.org/course/proglang
Brown's Intro to PL class: http://cs.brown.edu/courses/cs173/2012/Videos/
Yes, please do! Warning: F# will ruin other languages for you. I find it rather painful to work in basically anything else after using F#, with gradients of pain for different languages. Haha.
And that's a good question. I have basically every book written on F#, but I can't say I have ever used them for anything more than reference.
The official docs/guide/reference are actually really good, and I refer to them a lot when using some feature I'm not familiar with: https://docs.microsoft.com/en-us/dotnet/fsharp/what-is-fshar...
F# For Fun and Profit is well-known, but I can't say I use it a lot: https://fsharpforfunandprofit.com/
The same author's (Scott Wlaschin) book is very good: https://pragprog.com/titles/swdddf/domain-modeling-made-func...
As for books, I have always liked:
* Functional Programming Using F# by Hansen and Rischel (might be too simple if you are already comfortable with functional programming and is out of date every now and then with changes to F# that's happened)
* Expert F# 4.0 by Don Syme and others (contains a lot of nice things by the designer of F#
One of the latest books is Stylish F# 6: Crafting Elegant Functional Code for .NET 6 by Kit Eason. I have the first edition but haven't read it.
My personal recommendation is to take the approach of type/domain driven design. That is, I start off every F# module the same:
1. Define my types with discriminated unions, records, type aliases (such as for tuples) or single case discriminated unions. Use classes when necessary but try to prefer the more functional types.
2. Start writing functions against these.
And that's basically it. One thing to recognize with F# is that it mixes OOP rather nicely. Even discriminated unions and records, which are immutable, can have members defined on them, including operator overloading (something F# is pretty good about). They can even implement interfaces and be defined with generic types, which is also nice and powerful.
I have some projects that might of interest, since they're simple enough and illustrate the above process.
https://github.com/bmitc/the-ray-tracer-challenge-fsharp
https://github.com/bmitc/nand2tetris
Lastly, I'd suggest just starting up some projects. You could also take the Programming Languages course on Coursera by Dan Grossman. Part A uses SML, and you could port the examples and homework solutions to F# (I did so when I took the course). I also take books written for other languages and port the code to F#, usually taking a more idiomatic functional style. .NET Interactive notebooks (https://github.com/dotnet/interactive) are a great way to get started. You just need to install the .NET 6 SDK (which gets you F#) and then install the .NET Interactive Notebook extension in VS Code. That's it. There is also the book The Little MLer which gets people comfortable with discriminated unions (sum types), and I used the book and ported the examples to F#. I need to go back and finish that annotation project (https://github.com/bmitc/the-little-fsharper). I'll probably convert the script files to .NET Interactive notebooks if I do.
the oft recommended f# for fun and profit is good as a reference, but i personally haven't found it good as a tutorial. the explanations are often not expedient and show (too) many ways of doing things to get to the point. i go there when i have something very specific in mind. i often find the official microsoft f# documentation to be quite good and my go to reference.
as for books, there are a lot. none of them really fully resonate with me, although they are usually pretty good, but the book functional programming using f# by hansen and rischel is fairly nice. it is more academic in tone, although it was written a while ago against an older version of f#, so there may be some slightly out of date or style code. the book expert f# is by the language designer, and it shows some nice advanced stuff in a clear way.
i also recommend going through the little mler by translating the sml code in the book to f#. it will get you used to using types and pattern matching the way they are done in ml dialects. you will be able to do everything up until they cover the module system.
i have some very simple code here: https://github.com/nikofeyn/ray-tracing-with-fsharp/tree/mas...
it isn't documented or to my usual style, as it is an incomplete project. i was going through the book ray tracing in one weekend by peter shirley and didn't finish. and this code was actually "ported" from racket code that i had originally started the book with. so it went from c++ -> racket -> f#. however, it shows some representative f# syntax for some numerical stuff. i have some more f# projects that show more type-based programming and pattern matching styles, but they are in private repositories.
i personally just do not like python. it feels very sloppily designed to me, and i prefer scheme-based languages like racket and ml-based languages like f#. i have only worked in python when work has compelled me to, and i hated every instance of it. a large majority of it is that python is just difficult to reason about and is sloppy. that and the ecosystem, while vast, is very sloppy. i have encountered countless dependency issues and version headaches with python. it just isn't fun. all the work to get something working in python is just not worth it and unless you are reliant on some particular library, i personally don't see a reason to use it.
meanwhile, racket and f# remain as easy to develop code as python, except that the code developed works and works well. they are just extremely nice languages to use. they are the only languages i have used where it doesn't seem they are fighting me.
if you use python's async code, check out f#'s async expressions. they are extremely easy to use.
i highly recommend dan grossman's programming languages course on coursera. the first module uses sml (you can basically directly port all the code and your own code to f# for fun and very easily). the second module uses racket. and the third module uses ruby. i recommend it for any programmer and especially for some not used to the functional style.
I am a huge fan of MOOCs. I strongly believe that these courses and this style of education will be one of the greatest by-products of the modern internet. I was a happy and eager participant in the 'early days' (I took ~2 years off of work in 2013-2014 to re-charge, and took a number of online courses for fun), and here are some of my thoughts:
- Completion rate is a very poor metric to measure the 'success' of the concept. I attempted more than a dozen courses, but only completed ~4-5 of them. But that doesn't mean I didn't learn anything. For a number of courses, I got a good way through the material (75%+) but got distracted/side tracked (in one particular case, I was 90% of the way through a very challenging and interesting course[1] when a buddy and I decided to do a last minute trip to Mexico for some camping/surfing. Needless to say, it was hard to find internet access out there). Of the courses I completed, at least two of those I had to attempt more than once. But regardless of the final outcome, I learned a ton. There were a few courses that I didn't find interesting and walked away from, but for the most part, I learned something from every course, regardless of whether I completed it or not.
- By traditional metrics, I wasn't the best student in college. There were a number of reasons for this, but a key reason was the inability to focus during lectures. I just hadn't had enough life experience to learn how to optimize my ability to pay attention in class for multiple hours a day. In high school, the class sizes were small and the teachers were engaging enough to make it easy for me. In college (big public university) there were hundreds of students in each lecture and the professors were more interested in research than they were in lectures (with a few exceptions). I now know that I need the right balance of coffee, adequate sleep, and exercise in order to be able to sit through 4+ hours of very dry lectures, but it took years of hard won experience to find that balance. MOOCs are amazing because they let you optimize the 'lecture' time to best suite your schedule and your 'optimum time of focus'. And the forums were a great, asynchronous way to share knowledge between TA's and students (as opposed to my college experience where you had 1-2 office hours per week, with a dozen+ students competing for attention). Had MOOC-like teaching material (video lectures, forums, online exercises) been available when I was in college, I have no doubt that I would have done way better.
- Considering how expensive traditional college is getting, I think a very cool and plausible alternative would be to allow students to spend a few years doing internships/apprenticeships part time, and doing nano-degrees and MOOCs part time. A company could pay for the classes, as well as a stipend/salary for the internship. I learned programming and statistics on the job (seems like it's getting more rare these days for on the job training) but being able to take a step back and take more traditional classes on Coursera helped fill in some of the knowledge gaps that had been developing over the years. I feel like mixing both practical, in demand skills and theoretical knowledge at the same time could result in a much more engaging and deep understanding of the subject matter as opposed to the traditional way of all theory in college followed by all 'hands-on' in the real world.
Anyways, a bit of rant. But it's been a while since a MOOC post has made it to the front page of HN, and it's a holiday weekend!
[1] https://www.coursera.org/learn/programming-languages Back when I took this, it was just a single course. Looks like they broke it up into 3 parts. Would have been nice to have that option when I took it!
Have you taken the Dan Grossman's Programming Languages on Coursera? It gives a very detailed rubric– you're required to complete 3 peer reviews and a self evaluation with the same rubric. That being said the peer review is only worth 10% of your homework grade, the rest is done by the autograder. I haven't gotten a ton of feedback so far– just reviewing other people's solutions is probably more helpful. Still, it's better than some of the other courses. It would be great if there was an incentive for providing meaningful feedback– I don't know if rating your feedback would be taking that too far but it might be more effective than a simple wordcount.
My experience on EdX is limited to MIT and Delft– I'm looking forward to a time when I can try out one of the Harvard classes.