HN Academy

The best online courses of Hacker News.

Hacker News Comments on
Programming Languages, Part A

Coursera · University of Washington · 60 HN points · 69 HN comments

HN Academy has aggregated all Hacker News stories and comments that mention Coursera's "Programming Languages, Part A" from University of Washington.
Course Description

This course is an introduction to the basic concepts of programming languages, with a strong emphasis on functional programming. The course uses the languages ML, Racket, and Ruby as vehicles for teaching the concepts, but the real intent is to teach enough about how any language “fits together” to make you more effective programming in any language -- and in learning new ones.

This course is neither particularly theoretical nor just about programming specifics -- it will give you a framework for understanding how to use language constructs effectively and how to design correct and elegant programs. By using different languages, you will learn to think more deeply than in terms of the particular syntax of one language. The emphasis on functional programming is essential for learning how to write robust, reusable, composable, and elegant programs. Indeed, many of the most important ideas in modern languages have their roots in functional programming. Get ready to learn a fresh and beautiful way to look at software and how to have fun building it.

The course assumes some prior experience with programming, as described in more detail in the first module.

The course is divided into three Coursera courses: Part A, Part B, and Part C. As explained in more detail in the first module of Part A, the overall course is a substantial amount of challenging material, so the three-part format provides two intermediate milestones and opportunities for a pause before continuing. The three parts are designed to be completed in order and set up to motivate you to continue through to the end of Part C. The three parts are not quite equal in length: Part A is almost as substantial as Part B and Part C combined.

Week 1 of Part A has a more detailed list of topics for all three parts of the course, but it is expected that most course participants will not (yet!) know what all these topics mean.

HN Academy Rankings
  • Ranked #8 this month (apr/may) · view
  • Ranked #5 this year (2024) · view
  • Ranked #7 all time · view
Provider Info
This course is offered by University of Washington on the Coursera platform.
HN Academy may receive a referral commission when you make purchases on sites after clicking through links on this page. Most courses are available for free with the option to purchase a completion certificate.
See also: all Reddit discussions that mention this course at

Hacker News Stories and Comments

All the comments and stories posted to Hacker News that reference this url. - recursion, and how to apply it, and functional programming in general clicked for after this course.

Also Code Complete - after reading I finally understood what good code should look like.

Code Complete made me see the difference between scripting and engineering.
Oct 11, 2022 · 3 points, 1 comments · submitted by jackallis
A very interesting approach, language-wise:

This course is an introduction to the basic concepts of programming languages, with a strong emphasis on functional programming. The course uses the languages ML, Racket, and Ruby as vehicles for teaching the concepts, but the real intent is to teach enough about how any language “fits together” to make you more effective programming in any language -- and in learning new ones.

Tangentially related, but I have found the PL course [0] on Coursera taught by Dan Grossman to be really high-quality and engaging. Learned a lot from it.


I will second that heartily. Was one of the more mind expands courses I’ve ever taken.
What are some others, if you don't mind?
Nothing online, I’m afraid. Most of the best classes I’ve taken were at my brick and mortar small liberal arts college and were not computer science. I’ve also taken plenty online courses that I would call useful, and I’m glad I took them [1]. But Grossman’s is the only online course I’ve taken where I felt like there was a deep pleasure and joy in teaching your brain new and unexpected ways to think.

[1] Sedgwick’s algorithms class (useful and clear, but dry as hell), Martin Odersky’s scala course (solid, but probably a little dated by now), several others not worth mentioning.


I like learning new stuff, and expand my mind.

There are many courses on my to-do list that I learned about from HN.

I have found Sedgewick's course to be very dry (not intellectually, but physical vibe-wise) as well and was annoyed that I had to write Java.

Skiena, DPV, and a PragProg book ultimately taught me algorithms.

I have the Odersky course on my list as well.

A few years ago I did a MOOC called 'programming languages' which teaches languages like racket and ML.

In one of the intro lectures, the professor remarked that (paraphraaing here) 'now I am not naive--I know you will probably end up programming in Java or python when you reach the professional world, but the purpose of this course is not that you will actually go out and use racket in your life as a business programmer, but instead that your knowledge of racket will change the way you program in Java or Python'.

So there's really two types of learning--learning a language to use it, and learning a language as a sort of intellectual feast to bring back to your own.

This also has paralells in (human) language. The only languages I've studied are French and Hebrew. French has 'que' which can combine two noun phrases in a way that doesn't quite exist in English, and Hebrew has construct state.

[1] Sorry if I make a mistake here, Im not really very knowledgeable about either language, but I hope the general point stands.

That was a great MOOC by Dan Grossman - discussed a number of times here on HN.

The famous quote from Alan J Perlis:

"A language that doesn't affect the way you think about programming, is not worth knowing."

Great job!

I realize this is more about Rust and writing compilers. But if anyone is interested in finding out more about Standard ML, give a shot to the Programming Languages course on Coursera[1]. Part A is devoted to Standard ML (SML) . To say the instructor is great would be a huge understatement. The code we wrote for assignments used only immutable values, recursion instead of loops, partial application. It didn’t make me a hardcore functional programming proponent, but seriously broadened my horizons. On top of that, we used pattern matching extensively, which in combination with discriminated unions impressed me the most: using these two to model a lot of problems felt really natural.


And you also learn Scheme! I haven't taken course, but I've used profs online resources from it for self-teaching and they are great.
The Coursera course Programming Languages (Part A and B) by Dan Grossman teaches FP (and more) using SML and Racket. I enjoyed this course a lot. I would not recommend it for kids, but it should be great for students with some limited programming experience.



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.

I think maybe the Programming Languages A, B, C on Coursera is what you are looking for.
> #1 as irrelevant for everyone but themselves

I assume you then don't use the following features?

- GC

- Generics

- Higher-order functions

- Recursion

- Static scope (oh man)

- Type inference

- Lambdas, closures, ...

Take a look at [1] to see why FP might be useful. You'll be surprised how many interesting features they have, and will want some of those in your current OOP-focused language too


Programming Languages, Dan Grossman, UW. It is a 3 part course and a bit more intensive than other courses on Coursera with challenging assignments. It helped me gain a deeper understanding of statically vs dynamically typed languages. Designing a tiny language in Part B is the best part of the course. Concludes with a nice comparison between OOP and functional languages.
Did that too and it totally changed how understand programming (was a newbie back then).
Thanks for the suggestion. I will check it out.
Did this one when it was just one single course. The content is great, but the best thing by fat is the teacher. Dan Grossman is a natural teaching talent, and this course shows how one single teacher can make a difference.
dan is awesome. nice guy too.
I think Dan Grossman's Programming Languages courses are amazing if you have slept through the subject in university:
I took it the second time it was offered. One of the main reasons was it was as an excuse to learn Emacs. Does anyone know if the course still encourages using Emacs?
it does!
I did this course 5+ years ago and I still remember it fondly! I can pretty confidently say that it made me a better developer
As someone who learned to program outside of college, this course was one of my favorites.
Great class that really challenged me as a self-taught programmer. Rewarding assignments that pushed back the basics you often find in MOOCs
These are absolute gems! I remember how bummed I felt watching the last video of the last course because it was ending.
I wish there was a follow up. Brown published their book online, but it's not as fun without a structure.
+1! This is a three-parter and it was such a fun hobby for a few weeks when quarantine was kicking up. I had played with plenty of languages before but didn't realize the gaps in my knowledge. Would recommend.
Oct 25, 2020 · BoysenberryPi on Standard ML in 2020
I first came across Standard ML in Dan Grossman's Programming Language course on Coursera[1]. After previously trying Haskell and Scala, this is where the benefits of functional programming and static typing really clicked for me. Really wish the language had caught on outside of academia so I had an excuse to use it more. In addition to the implementations mentioned in the blog post, The University of Chicago created Manticore[2] and Tohoku University in Japan created SML#[3]




Thanks for sharing Manticore! I didn't mention SML# because most of the documentation is in Japanese and it's hard to find recent info. There is an unofficial fork on Github but it explicitly states that it is unofficial so... not something I'd recommend to a general audience.

Edit: nevermind! I checked out their docs again and it seems to be decently translated. I'm still not sure where their code is actually hosted, just that you can download releases. So added it to the list of major implementations!

I was introduced to SML via Dan Grossman's Programming Languages course [0] and it's quickly become my favorite programming language to work through problems and brain-teasers.

Shame there isn't more non-academic support for it.

[0] -

That is such a good course. I really enjoyed it and need to go back and finish the third part with Ruby.

If you like SML, check out F#. I did part one of that course in SML, F#, Typed Racket, and Scala. F# was by far the cleanest and most concise for each homework assignment. (Most code was written in SML first and then ported to the other languages.)

F# has become my side-project language.

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:, 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:, which I think would be far more relevant to modern programmers than studying compilers specifically.
Why is almost every answer on this thread is related to Machine Learning. The question was about programming. There is 3 part series from University of Washington on programming languages covering Standard ML, Racket and Ruby. It compares and contrasts functional programming and Object oriented programming in detail by teaching 3 different languages. I believe this is a great resource to start with. Here is the link. -->
One of the best courses i had. It gave an First view of functional programming. And ML, is just great. And now I can see many languages influenced by It.
I also highly recommend this course. It does a great job of comparing/contrasting functional and OOP.
I did part of the ML course. I've been pondering over which language to choose to advance my functional programming journey. I've been torn between choosing Lispy variants such as Scheme, Racket, Clojure etc or the ML variants such Scala, SML, OCaml, F# or go nuts and do Haskell! :D But I'm a data analyst by profession and I'm 35 years old. So I need to choose something wisely. I'm studying statistics at the moment and the most wise choice for me is R. I already do some work on Python. R is based on Scheme and has a lot of functional aspects. Some of the answers related to Machine Learning here are relevant to me. But for the question, I also believe the Washington University course is a strong contender. Hopefully, I'll have the time in future to learn some of it.
May 10, 2020 · nikofeyn on Racket is 25
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.

I actually finished that course when it first came out (and was a single course as opposed to a 3 part breakdown) way back, like 4-5 years ago.

Thanks all for the suggestions! :)

programming languages (parts a, b, and c) by dan grossman

introduces the underpinnings of programming languages via standard ml, racket, and ruby.

I second this recommendation. A really good course, and if you do all 3 parts it's really the equivalent of a full university course. Covers the main concepts in modern programming languages, such static vs. dynamic typing, OO vs functional, and does so I consdierable depth, with reasonably challenging programming projects. Even if you think you already know this stuff, it's a good review and I guarantee you'll learn a few new things.

Also, Dan is a good professor and is really enthusiastic about the subject.

yep, it's a very fun course and very well organized, including code reviews for homework. i fixed some issues found in mine and enjoyed reviewing others' work. i do wish there were programming assignments for sml's module system though. that part felt a bit tacked on.

i still need to go back and finish the ruby section. at that point in the course, i got distracted with other things.

I am taking this course[1]: Programming Languages. It emphasizes on big ideas behind languages and functional programming which is very interesting and enlightening.You will implement a type checker and interpreter through this course(I am struggling ML's pattern matching now but feel quite pleasant ).


One of the best courses ever.
Yes, the only course I ever finished and finished wiser of the scores I must have enrolled in so far.
I took this course with Dan at UW. It was definitely one of my favorite classes. The way he taught made things really interesting.
I highly, highly recommend skipping Haskell for now and learning statically-typed FP using this excellent free online course:

The lecture videos are short, about 10mins each, and Professor Grossman explains the concepts carefully and succinctly, within a fixed teaching framework so you have a predictable learning experience with each concept. It's by far the best way to get into the mindset of typed FP.

I like the advice, but unfortunately not an option in my case -- very short consulting gig
Feel free to email me if you’re stuck. I’d be happy to help you out.

I highly recommend spending a little time trying to understand the basics. You might find “Functors, Applicatives, and Monads in Pictures” helpful:,_applicatives,_and_...

Type classes, functors, and monads are assumed knowledge in most documentation, as they are foundational concepts in Haskell. Just like math, you must know addition, subtraction, multiplication when learning algebra.

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!)

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.

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.

>(People, please don't let beginners start with webdev!)

I actually think Web Development should be what every new hobby programmer should learn. It is the quickest, easiest way to get simple, understandable, showcase-able results.

I kind of miss the good old days of WYSIWYG Dreamweaver and Front-page.

Unless you're really setting out to create something for your already existing home page or great web idea, or you're already a web designer wanting to visit the coding side, too, I think web development is a way too heavy load for the beginner.

You have to not only learn your language of choice, but also HTML, maybe even CSS and the fight with the query/respond nature of HTTP and/or asynchronous JS, callbacks etc..

Maybe if you're starting out with some Scheme setup where you've got an abstract page description DSL and a continuation-based framework.

No problems with keeping that as an intermediate, "now you're a real programmer" goal. But let's start out with "input name/fahrenheit -> print greeting/celsius" for a while and learn about structure, data types etc.

Simple graphics get you something that you can show your relatives and friends, too ("I made space flappy bird / the mandelbrot set"). And with way less mental overhead.

Start with this:

Free online course that teaches statically-typed functional programming using SML as a teaching language. Lecture videos are short and to the point. Prof. Dan Grossman is widely recognized as a great lecturer and he gets the ideas across really well.

From there learn OCaml, which is the ML with the widest industry adoption.

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!






> Uses script to copy programming course.

That's a little meta, don't you think?

Welcome to Lisp: :-)
thank you!
Caveat emptor: Standard ML is not widely used in industry and does not have a large library ecosystem, so if you do recommend it to clients, make sure it's clear that they'd want to follow up with something like Scala or Ocaml, which have far more users/libraries. It's just that for really understanding functional programming, Standard ML is fantastically clear. (Although actually, that Scala coursera course I linked to above is by Martin Odersky, and is also pretty darn good, especially if you're already committed to the JVM.)

Others have mentioned Elixir, which would also be an interesting option to explore. The main difference being that with Elixir you're leveraging Erlang and BEAM (which gives you a fantastic platform for actors and lightweight threads), versus Java and the JVM in the case of Scala (which gives you access to all of Java).

I almost forgot to mention: Matt Might has an excellent blog post about what all of these "advanced" programming languages offer:
f# (and also ocaml and sml) have all those and much more. they are much more consistent and principled in their design, which makes things simpler to understand.

for example, in all three languages above, expressions are much easier to understand because they always return a value. this makes code easier to reason about. this is not true in python.

the languages i mentioned do have static typing but they have type inference. so you get the best of both worlds. you do need to type annotate at some points to clarify things, but this isn't a problem as it documents to both the user and compiler.

given your above reasons, you owe it to yourself to learn an ml. there is the programming languages course on coursera by dan grossman, which uses sml in the first part, and the ocaml mooc just started where you still have time to register and complete it.

> f# (and also ocaml and sml) have all those and much more

F# has curly braces. Also, as you say, it requires some type annotations.

I see that F# has a REPL, but it seems bolted on as an afterthought instead of being an integral part of the language. (Also, it's not clear whether the REPL is available in Mono on Linux. I am allergic to Windows and anything built by Microsoft.)

> expressions are much easier to understand because they always return a value. this makes code easier to reason about. this is not true in python

Huh? Python expressions always return a value.

Perhaps what you mean is that Python also has statements, which do not return a value, whereas these languages do not--everything is an expression, as in Lisp?

> you owe it to yourself to learn an ml

I don't owe it to myself to learn anything unless I decide to. I wasn't trying to convince anyone else to use Python; I was just giving reasons why I like Python. Please extend me the same courtesy when you talk about things you like about your favorite languages.

okay, f# has curly braces. but not in the sense of other C-like languages like c++, java, and c#. they are primarily used for sequence expressions and computation expressions like async.

> I see that F# has a REPL, but it seems bolted on as an afterthought instead of being an integral part of the language. (Also, it's not clear whether the REPL is available in Mono on Linux. I am allergic to Windows and anything built by Microsoft.)

well that first sentence is simply not true, and i don't know what gave you that impression. f#'s repl, f# interactive, is available on linux through mono and will soon be available through .net core. i can't help you being needlessly allergic to a major operating system or company. f# came out of microsoft research.

> Huh? Python expressions always return a value.

they do? take:

  def test(x):
so what does


> I don't owe it to myself to learn anything unless I decide to. I wasn't trying to convince anyone else to use Python; I was just giving reasons why I like Python. Please extend me the same courtesy when you talk about things you like about your favorite languages.

i don't know why you're upset. i am not for sure where i was discourteous. i didn't mean anything by my statement other than to check out the languages and courses (the coursera one is very good). if those are your reasons for python, i just thought you would honestly like an ML-based language. i just used "owe it to yourself" as an expression, which apparently came out wrong through text. of course you don't owe anyone anything. i was just making a suggestion.

Replying to your reply of the child comment:

> i guess that is true in python3 but it is not in python 2.7.

No, it's always been there.

    >>> def f():
    ...     pass
    >>> f() is None
>>> test(2) is None


i guess that is true in python3 but it is not in python 2.7.
False. You're just not familiar with how the REPL works.

    >>> None
    >>> print(None)

In the future, you might want to refrain from strong criticism of a thing you're not familiar with. That habit leads to all sorts of -isms.
i do know how the repl works. i explicitly tried it out. i defined the function just as i said and ran

  test(2) is None
and got false. i just now went to try it out again at home and got true. i don't know what to tell you other than something must have got shadowed somewhere.
Here's what I get from the Python 3 REPL:

    peter@localhost:~$ python3
    Python 3.5.2 (default, Nov 23 2017, 16:37:01)
    [GCC 5.4.0 20160609] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> def test(x):
    ...     "something"
    >>> test(2) is None
And Python 2:

    peter@localhost:~$ python
    Python 2.7.12 (default, Dec  4 2017, 14:50:18)
    [GCC 5.4.0 20160609] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> def test(x):
    ...     "something"
    >>> test(2) is None
If you post such a transcript from your REPL session where you get False, it should be easier to tell what's different between your setup and mine (which is a stock Python install on Ubuntu 16.04).

However, there is another even more direct experiment you could have run at the Python REPL to see what Python expressions return: just type the expression directly at the REPL and see what it prints back at you. In Python 3:

    peter@ToshibaSatellite:~$ python3
    Python 3.5.2 (default, Nov 23 2017, 16:37:01)
    [GCC 5.4.0 20160609] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> "something"
And in Python 2:

    peter@ToshibaSatellite:~$ python
    Python 2.7.12 (default, Dec  4 2017, 14:50:18)
    [GCC 5.4.0 20160609] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> "something"
So, in your test function above, the expression "something" does return itself; it just does it inside the function, and that return value then gets thrown away when the function exits, because you didn't return it from the function itself.
i know how to use the repl. i moved between computers during comments and wasn't able to inspect my repl session where it originally returned false. as i mentioned, i must have redefined something or shadowed something which caused confusion, and i just didn't realize it at the time.
> of course you don't owe anyone anything

Yes, and thanks for acknowledging that. But then the phrase "owe it to yourself" didn't really communicate your intent correctly, which is why I objected to it.

Aug 23, 2018 · 44 points, 14 comments · submitted by tosh
For anybody looking for a similar-ish syllabus with different material, Matthew Flatt's introductory programming languages course is available online at [0]. It's in Plait (formerly PLAI-Typed, a smaller dialect of Racket) and was really a great class, in my opinion. (I took this as a junior at the U.)


Took this course when I started moving towards software development and I thought it was great. It has a higher academic level then most introductory courses and its been great for developing intuition about the craft
How much is it? (It seems like there is no way to see without creating an account - yuck)
it’s free. you can pay for each part to get a certificate or just take it for free.
As a (serious) hobbyist, I thought that class was fantastic.
I’ve taken this course and it’s excellent, all three parts.

It makes me wish there were a modern standard ML, without laziness, typeclasses or Object Oriented-ness.

I guess the dream died with its creator.
Well, given that OCaml almost doesn't use it's optional Object Oriented-ness, that might be what you're looking for.
> Well, given that OCaml almost doesn't use it's optional Object Oriented-ness, that might be what you're looking for.

so... you use OCaml without modules ?

Well, isn't that just Standard ML?
Would a non-OO style of OCaml be what you want, or if not, what is it missing?
Not knowing any ML myself, what is it about ML that you want to retain?
would Elm do the trick?
Try looking at
As a self-taught developer, I used to think that some of the theoretical elements were overhyped. I can build iOS apps that work, and I did just that for the last 2-3 years. However, many of the programs that I wrote have not been as easy to maintain as I would like and some difficult to fix bugs have popped up overtime, both of which are due to a lack of deeper understanding of CS fundamentals. Last year I started interviewing and was ridiculed at one company in particular for a lack of CS knowledge. Afterwords I started exploring a lot of the CS concepts listed in this link and I have since found numerous ways to improve my code quality and have a better understanding of how CS best practices came to be. I also used to think that algorithms and data structures were relatively useless for an iOS developer, and I was able to do the job without them, thus proving my point. However, after gaining a better understanding, it quickly becomes clear that things like view hierarchies are simply trees and understanding ways to traverse these hierarchies can lead to much cleaner code. With the open sourcing of Swift, I also became more interested in understanding the language, but a lot of the language design decisions didn't make sense to me until I gained a better understanding of CS fundamentals. I have found the programming languages course on Coursera [1] to be particularly useful, and have also greatly enjoyed the book Designing Data Intensive Applications [2]. There's also a great video from this year's WWDC that really inspires algorithm study and use in everyday applications [3].




A very recognizable problem! While I'm definitely still trying to figure this out for myself, here are a few of my thoughts and experiences:

1) books usually trump courses books are much easier to browse through. pick and choose what you need. Do make notes, or in 6-12 months it will be like you had never read it at all. Courses seem nice in that they offer varied learning - a lecturer, assignments, a forum for questions, a shiny certificate at the end.. but you have little control over pacing, and there just aren't enough solid ways to judge beforehand if the course is any good. Trudged through many hours of bad/repetitive content before I understood this :)

2) don't memorise specifics, understand design choices if you haven't done so already, I can really recommend looking into how languages are built - what are the paradigms / design choices. I'll even recommend a MOOC: A focus on design makes it much easier, at least in my experience, to pick up a new language and become an 'expert' at it; nobody will turn to you for help writing a loop or grokking a few conditionals (I hope). But understanding, let's say, prototypal inheritance in JS and how this differs from other languages, or the effect of having (or lacking) functions as first-class citizens, figuring out what are the language core concepts and what is just syntactic sugar - this let's you reason about languages and problems on a whole different level.

3) if you have the opportunity; coach/teach trying to teach stuff to a few interested souls is a stellar way to force yourself to order your thoughts. Pick something that's right at the edge of your audience's skill level, and explain it in the cleanest, concisest way you can. It's a win-win, in my experience.

4) create something the hardest part about learning a new language is not the language specifics, but learning the ecosystem. What are the tools and libraries you must use or avoid, what is the right dev setup, how do you build/deploy, and in some god-forsaken cases, how do you even version control a project? The only way to really learn this imho is to just start building a small project.

These are only partial solutions; it still takes a lot of time and effort, and I probably haven't come close to maximising efficiency of self-study :). Don't forget to have fun though!

Looking forward to reading more about this.

Linear Dynamical Systems by Stephen Boyd of Stanford:

Programming Languages by Dan Grossman of University of Washington:

what's good about the first one?
I've also gone over those lectures a couple of times. I'm not even sure why I started watching them, since I knew absolutely nothing about linear dynamical systems before hand, but it really changed my life! It taught me techniques that I now use all the time, and I think are very neglected within my field (data analysis/forecasting).

If your not familiar with it, it's an extremely versatile framework for modeling and analysis of all kinds of systems. It will give you new insights into linear algebra, time series analysis, stochastic models, Fourier analysis, Laplace transforms, and many other areas.

He's a brilliant (and enthusiastic) teacher, and he has lots of resources on line, including a text-book length exercise-set which I've printed out and had bound because it is so awesome.

Sounds really good, I'll make some time to watch it. Thanks!
Programming Languages, Dan Grossman (Coursera has split it into 3 parts now):
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.

I see that they have split the course into 2 parts.

Actually, there are three parts. The course uses Standard ML, Racket, and Ruby as vehicles for teaching the concepts. The intent is to make you a more effective programmer in any language.
It used to be 1 course, they've split it into 3 parts for commercial reasons I suppose.
He says he didn't, and that the summed price of the three courses are the same as if it were to be a single long course.
Could you expand on how it changed things for you? How did you learn them before vs after?
I already see some good responses to your question.

As for me, before this course, learning a language was a mechanical process. I learn the syntax, learn some idioms and go with it. But, after this course, as the other commenter put it, I started learning every language as a set of features. That opens up a whole new world. For instance, when learning a new language, you seek out the features your are interested in and then figure out how that language lets you use it. For example, does a language support abstract data types, what paradigms of programming does it support, is it imperative or functional, lazy or strict, is the language supposed to be used as a bunch of statements or expressions, can common idioms be implemented as simple language functions or do I need the language to support it internally etc, does it support lambdas, does it do lexical or dynamic binding etc. The course also takes you through ML, Racket and Ruby and gradually exposes you through this concepts and in parallel explains what the trade-offs are as you give up once paradigm for another.

So, after the course, next time if you open up a beginners guide to any language, you will be seeking our answers to high level questions. The syntax to use will be learned automatically as you use those 'concepts'

Dan Grossman is a an excellent teacher. His passion for programming languages can be seen in his teachings. The homeworks are very relevant and helps you solidify the concepts. I am thankful to him for offering this course.

Hope this makes sense.

It dispels all the magic around programming, by helping you build a knowledge of computer programming agnostic to any programming language. Dan Grossman is a superb teacher and the way he ties concepts together is awesome. I'll be forever glad for this MOOC.
> It changed the way I learn any new programming language.

I can say the same and I can offer my reasons: until this course I saw every language like a little island; after this course I understood that programs are just a collection of features: various typing systems, static/dynamic scoping, lazy/eager evaluation, etc. It's a ton easier to learn a new language by identifying these features than by looking at a language as a big blob. This also made me realize that languages are not little disjoint island - they're overlapping a lot instead.

The course was the way I got into racket and other lisps and this allowed me to read SICP. Since then I've been doing all sorts of toy interpreters/transpilers for fun and it allowed me to get an idea of what's happening behind the scenes in real languages. For example, I used to think that closures are magical, but after implementing them as part of the course they were a piece of cake afterwards. You will get a profound satisfaction when you implement call/cc yourself and suddenly you understand how try/catch or generators work.

Interesting. Did you feel like you needed a strong understanding of compilers or automata to really grok what was going on (I think automata relate to programming languages, but could be mistaken)?
None at all. Automata are used to turn a program from its textual form into some manageable data structure that something else will consume (actual interpreter/optimizer/compiler). At some point in the course (in the racket part) you will be asked to implement an interpreter for MUPL (made-up programming language), but the programs are directly written as a data structure - so no need to parse; in racket both data and code look exactly the same - it'll be a breeze.

I think the only requirements for this course is some plain procedural language (C/Pascal).

I took the same path and went back to reading SICP. But, this time around is was very easy. I had the same experience about implementing closures and the embedded language.
That's also the one I would have picked.

I liked that it used ML, and the parallel/isomorphism between functional and object-oriented programming was really well illustrated IMO.

Really good to develop basic intuition before going into more advanced stuff.

Feb 06, 2018 · jasim on Reason ML toolchain
ReasonML is IMO quite ready for production work if you use it for building server-side applications with NodeJS or rich front-end applications with React (ReasonReact).

The target audience for Reason (at least for the moment) are web application developers who want to level up as programmers and want to build elegant, sturdy production systems.

Reason and Elm together are democratizing statically typed functional programming and I believe that the next 10 years are going to see a massive change in the programming language landscape, with the practice of typed FP finally finding adoption in mainstream commercial programming.

The allure of Reason is in its packaging of OCaml to the web browser (which is made possible by BuckleScript - the actual OCaml to JS compiler doing the heavy lifting), its syntax that is familiar to the vast majority of programmers today, and the large ecosystem of bindings, libraries, and documentation that the team has put out.

OCaml is a very pragmatic language; its main pull is its powerful static type system and immutable, functional programming, but the "O" in OCaml stands for "Objective" - it is an implementation of CAML with support for object-oriented programming. But you almost never need objects. OCaml's module system and its idioms allows you to write well-encapsulated code without mutation, and when you actually need to write honest to metal imperative code, you can do it with abandon because OCaml is not a "pure" functional language like Haskell.

The term static type system might put off programmers whose only exposure to types were with Java, C++, C# and similar languages. But this thing is very different. Types in OCaml are more like structs in C; you just say the shape of your data, and you write pure functions that operate on them, and that's pretty much it. The magic happens in how you define the shape of your data. "Making invalid states impossible" is the siren call for statically typed FP languages, and from that flows a lot of natural constraints that can teach us how to structure programs.

The following links illustrate the promise of Typed FP very nicely, do watch it so that you'll have some inkling of the fun you'll have when you start learning ReasonML:

Designing with Types: Making illegal states unrepresentable by Scott Wlaschin.

"Making Impossible States Impossible" by Richard Feldman.

Ideology by Gary Bernhardt.

Effective ML Revisited by Yaron Minsky.

Programming Languages, Part A by Dan Grossman.

I always recommend for learning FP, the professor has fantastic explanatory videos that are really clear and concise. You'll get the most out of it from doing the exercises, but you can still take away a lot from just watching the videos.
Thank you. I'll check that out.
IMO, the best functional programming resource out there is this free online course by Prof. Dan Grossman at UW:

He focuses on teaching the syntax, semantics, and idiom of Standard ML, a classic functional programming language that's closely related to OCaml, Haskell, and others. He has a gift for explaining simply and clearly and keeps his lecture videos short (~10min) which helps to absorb their info. Check it out:

I recommend something similar ... Prof. Dan Grossman's Programming Languages course in Coursera, taught using Standard ML:

He starts by teaching statically typed functional programming with an emphasis on understanding semantics and idioms; then in the following modules he covers Racket and Ruby to compare and contrast dynamically typed homoiconic programming and object-oriented programming.

Rust is not a functional programming language :-) it has features which are ML-like, and it has first-class functions, but it doesn't really encourage functional idioms like the ML languages do.

If you want a great intro to ML-style statically typed functional programming (without the Haskell-style monads and functors jargon), check out . You'll get a lot out of even just going through the (10 minute each) lecture videos, Prof. Dan Grossman is a great explainer and it's a treat finding out the cool syntax, semantics and idioms of an ML language.

Just want to reiterate the comment at and say that learning specifically statically typed functional programming totally changed me as a developer. It opened my mind to the semantics of programming languages and to the design of programs in the small and in the large.

If you're writing C, then you're a developer, no doubt about that. But if you're interested in the 'meaning' of programming and software engineering, then I highly recommend learning functional programming. Here's an excellent course:

Feb 23, 2017 · 2 points, 0 comments · submitted by randomname2
Feb 23, 2017 · yawaramin on Tour of F#
It's a great resource for F#. If you also want to get really strong in functional programming fundamentals I highly recommend taking Prof. Dan Grossman's free online course --he's a great teacher and the subject matter is great for all levels of experience.
Are you a relative newbie at functional programming? Do you have about a month? Then I highly recommend Prof. Dan Grossman's free online course:

He teaches the syntax, semantics, and idioms of ML-style typed functional programming using the Standard ML language as a teaching vehicle. His explanations and course progression are really good. It will open your eyes to FP.

I can definitely recommend the University of Washington's Coursera on Programming languages. It's available here, and starts every few weeks I think: You'll learn SML (a strongly typed functional language), Racket (in the Lisp-scheme family of languages), and Ruby (to compare the previous languages with object-oriented ones). You'll even write your own language on top of Racket. It is a challenging class but I can say for sure that it has changed the way I think about programming.
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] 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!

In one of the previous MooC discussions some people indicated that they felt guilty for not finishing classes, which might be a deterrent.

I think there is value in having someone pick good ones, so you don't waste time starting things that are poorly recorded, etc.

The site up thread is good for this-

My project ( is built to help discover standalone lectures (conference talks, etc), which I hope helps the people who feel guilty not finishing stuff :)

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] (Starts up again on the 9th of January :) )

Seconded! Programming Languages is wonderful. Easily the best I've taken in Coursera (and better than Odersky's courses).
Jul 13, 2016 · 4 points, 0 comments · submitted by chmaynard
For those unaware, Coursera shutdown their old platform on Jun 30th [1].

Many of the courses on the old platform are slowly coming back on the new platform. When I built the list [2] of courses on the old platform the course count was 472, now its around 390. Some of the notables that I was excited to see come back are:

Neural Networks for Machine Learning with Geoffrey Hinton [3]

Computer Architecture from Princeton [4]

Programming Languages from UW by Dan Grossman [5]

Introduction to Natural Language Processing by Dragomir Radev [6]

Many of these courses were last offered a couple of years ago. Hopefully more courses form the list [2] start coming back.







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 -

[0] -

[1] -

[2] -

I can imagine someone being overwhelmed by all of those at first glance (in OP).
thanks , your links look way more reasonable than pure theory and mathematics for new comers who just want to implement simple programming languages and compilers.
There's a difference between learning about programming languages and learning about programming language theory. The class you linked is squarely in the former camp. It's a bit confusing because they use PLT to stand for "Programming Languages and Translators" where I usually see it referring to "Programming Language Theory".

Honestly, "programming language theory" is a bit of a misnomer. It's less a theory for programming languages and more a theory of CS from a language perspective. (Where theoretical CS is a theory of CS from a computational point of view.)

Programming language theory is interesting in and of itself and is fairly distinct from the sorts of things you'd learn in a normal programming languages course or by implementing your own language. I'm not saying either of those is useless—I'm a big fan of doing both!—just that they accomplish fundamentally different things. Your advice is good if you just want to implement a programming language; the linked repository is good if you want to explore PL theory.

PL theory shares a lot with formal logic and the foundations of mathematics. The main areas are things like type theory (a special approach to formal logic) and semantics (akin to proof theory or model theory).

What you'll learn by reading the books linked above is almost completely disjoint from what the class you linked covers.

I went through the videos of a coursera class for Programming Languages with Dan Grossman.

He starts teaching programming with ML and then moves to Racket and ends with Ruby.

I had tried to teach myself Haskell several times but it always fell flat. I ended up loving ML and Racket (Especially Racket) the 1ML does look very interesting. Racket is pretty amazing for me. I learned a ton and was able to really improve my code in Python and R.

"Programming Languages" -

"Compilers" -

are you me ?
Programming Languages is one of those courses that just keeps on giving.

A great basis for functional and Lisp fundamentals. I'm just starting a journey into Erlang and that course has meant that the switch isn't as difficult as it could have been.

The course format was interesting. I'm not 100% on board with doing peer assessment, but I did like being able to see how other people handled the assignments.

I love R and I love programming in it, but I have always thought I need to learn Julia due to a few things including speed, but that the R community keeps coming out with great answers to those questions where Julia keeps my interest. I don't see how this would speed up my typical R programming or code to be worth learning Haskell. What am I missing and yes I read the whole article.

I have found Haskell very difficult to use with Cabal and its package management. The reason I went to Haskell was to teach myself functional programming. After struggling and going through 2 books I still felt like I hated Haskell due to making the environment just work. I work in three different locations and to get all 5 computers to work in Haskell was a serious pain. This lead me to see what else is out there. It lead me to which introduced me to Racket and I loved it and felt that Racket was the perfect fit for me.

I've long had an unrealized dream of doing something similar with R and Racket as the HaskellR people have done. I've thought that it would be cool to:

1. implement R or something very akin to R as a Racket language. I'd call it "Arket" because is far more Googleable than R or Racket ;-) Functions would be callable either from Arket or Racket.

2. Ensure that all my important R packages work with Arket, either by porting or by virtue of similarity between Arket and R.

3. Use Racket for everything.

I think this would be great until I realize I would need to do a lot of work to create this.

Best part is:

> I'd call it "Arket" because is far more Googleable than R or Racket

> I have found Haskell very difficult to use with Cabal and its package management. The reason I went to Haskell was to teach myself functional programming. After struggling and going through 2 books I still felt like I hated Haskell due to making the environment just work. I work in three different locations and to get all 5 computers to work in Haskell was a serious pain.

Package management is certainly the worst thing about Haskell at the moment. Just yesterday I had to fight with cabal, and sit through hours of compilation, to build my application with profiling enabled :(

There's recently been a surge of activity in this area though, which seems to have been driven by FPComplete and consulting with industry:

- First there's "Stackage", which is basically a curated version of the package repository Hackage. Anyone can upload a new package to Hackage, and package authors can make breaking changes whenever they like. Stackage takes consistent snapshots of Hackage, where the package versions are known to work together.

- Next there's "Stack", which is an alternative UI for Cabal (ie. it replaces the commandline tools, but uses the same libraries and infrastructure). Nice features of stack are that it can fetch/install GHC (so "bootstrapping" is much easier), and it doesn't use a global package database (cabal has this feature with "sandboxes", but they're opt-in).

- Personally, I use Nix for managing Haskell packages. It's a bit like stack or cabal sandboxes taken to the extreme, although its Windows support is still pretty experimental. It will fetch pre-built packages from a cache, rather than building stuff locally (as long as you're using the defaults, at least).

Take a look at for more info.

> This lead me to see what else is out there. It lead me to which introduced me to Racket and I loved it and felt that Racket was the perfect fit for me.

Racket (and Scheme in general) is also an excellent functional programming language. Having dynamic types and macros makes it a very different beast to Haskell, so it's definitely worth learning both :)

> Having dynamic types and macros makes it a very different beast to Haskell,

Can you speak to how the type systems in Typed Racket and Haskell differ?

I ask because I too have tried scaling Mount Haskell and noped out not long after the base camp. If I continue with Typed Racket, am I getting some or most of what I'd get by learning Haskell? Or is Haskell simply a beast I must slay to become whole?

Sorry, I've not used Typed Racket so I can't comment. I've only played around a little with Racket itself, although I've used various Schemes in anger (and more Emacs Lisp than I'd like!)

One cultural issue, rather than a technical one, is that the whole of Haskell is strongly typed, lazy and pure; there's no getting away from it, so every idiom, library and API must take them into account. I imagine Typed Racket's ability to mix and match features will result in more "conservative" code (ie. choosing the type system to match a known approach, rather than inventing a new approach to fit the type system).

That's a good answer. I'm still fairly novice in Racket, so I don't yet have a good intuition for where Racket is asserting its own cultural norms. Haskell definitely communicates its concepts of purity early on, and so I can see where the community would continue to push itself in these directions.
You should give Haskell another shot. Since last you tried, this happened: In fact using stack is the recommended installation method for HaskellR, rather than using the cabal-install command.
maybe take the MOOC

at one point you write a small evaluator, then extend it through macros. Shows you how to get the linguistic trait you'd like in a few lines. One thing lisp has been used to demonstrate since its birth.

(the course uses ruby and sml for other subjects)

I am working through this coursea course via YouTube and I also found some github repos that have the course's homework material.

The first language is ML and than moves to Racket. Really learned a ton just doing the first weeks. It is more of a CS 202 Programming Languages course which was perfect for me since I really wanted to learn more about functional programming.

I took the second live offering of Dan Grossman's class on Coursera in fall 2013. There was another in the last year, so if the pattern holds, there would be another in the next few months or so.

I sure hope so I really liked his style. At first I was like oh no another syntax is 75% of material, but it ended up being described and explained clearly.
The best part of the course for me was that it gave me an excuse to learn Emacs and a framework in which to do it. Painful no doubt, but now I have become spoiled.
If you haven't had much functional programming experience I can't recommend Dan Grossman's Programming Languages class on Coursera enough.[0] You go through three languages in the course, Racket, ML, and Ruby.


Apr 14, 2015 · jskonhovd on F# Survey 2015 Results
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.

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#.

I've enjoyed the following resources:



Dan Grossman's Programming Languages Coursera course -

The Racket docs -

Chris Jester-Young's StackOverflow answers -[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

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.

The Programming Languages course on Coursera ( spends about a third of the course on SML before moving on to Racket and Ruby. It might be of interest to others who want a somewhat introductory course which uses ML.
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.
Greatly suggest to try sml through this course. I'll never forget it.
Sep 10, 2014 · jskonhovd on Swift Has Reached 1.0
I don't know if Swift would be the best language to learn programming. Python is probably a better option. I would avoid platform specific languages until you are hired to work in that space. Open platforms like Python are much easier than close platforms to get started in Computer Science.

A good place to start with python would be the Introduction to Computer Science course on Udacity.

If you are interested in ML, I can recommend taking the Programming Languages course on Coursera after the python course.

The Programming Languages course on Coursera: highly recommended
Martin Ordersky hisself is teaching Functional Programming in Scala starting September 15th:

If you don't know C, or Python or Ruby, there's always "The hard way" with Zed Shaw:

October 2, Coursera is abain offering Dan Grossman's Programming Languages, it covers general concepts in programming language design using SML, Racket, and Ruby.

Thanks for the links. I am really interested in functional programming in Rust and Scala as well as some systems level stuff with Go and Rust again. I will check these out.
The "Programming Language" course at coursera [1], which is directly adapted from a course at U. Washington by Dan Grossman [2] features SML, Racket and Ruby as three languages exhibiting different properties (FP, OO and static typing).

(I have to say that it was extremely good !)



I took this class and enjoyed it; it was my first experience with scala, but I had previously taken grossman's programming languages course which introduce me to FP (

Actually I thought grossman's was better at giving a comparison of FP and OO and hit on some more of the theory in FP (for example, odersky doesn't talk about the expression problem, but grossman did).

There will still be a lot in scala that's confusing after taking this class, but it's trying to teach the concepts rather than the language details.

That being said, I really enjoyed it and would recommend it.

Scala is an interesting blend of FP and OO. Just be aware that the ML-style languages (or even a lisp e.g. Racket) really feel more like FP. The blend is what makes it a mind-expanding course.

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

For some reason the Programming Languages class is offline now.
That sucks, sometimes the just let you watch all the videos even if the course isn't running. Wonder why different courses have different policies
Here you go:
"No sessions available."

I guess I expected a video archive, not unlike the SICP playlist as it exists on YouTube in various forms.

You can email him and ask him to make them available. I've done that for other coursera courses that didn't publish the videos after the course finished.
You can find the videos of the Programming Languages class together with the slides and handouts here:

Dan Grossman's Programming Languages class on Coursera includes a good treatment of OOP in the later weeks.

Even though I found the Ruby/OOP part of the course less interesting than the ML/Scheme parts, I feel like it gave me a much better understanding of OOP.

Actually the optional piece where he went through a derivation of OOP at the end of the Scheme portion was also one of the most helpful things for me.

To be honest, I pretty much lost interest in OOP. I found the ML/Racket parts of the course much more interesting (and less confusing) - even though I barely knew any FP and had actually studied some OOP. Perhaps I was biased, either against OOP or Ruby, which was used to teach it. Hmm...
Same here, in terms of the practical elements of the course. I still found Dan Grossman's lectures entirely engrossing, and I'm not just saying that because I noticed he was a HN user.
I think those are different Dan Grossmans. (Dans Grossman?)
Ah, thanks for letting me know! That could have confused me.
Nov 25, 2013 · naiquevin on Why Class?
I can somewhat relate to the conversations in the article. While I admit that I don't think I used OOP correctly, since I started using more functions instead of classes (in Python, my primary language), I observed that it has been more convenient to reuse and refactor existing code.

Another observation is that it's far easier to read someone else's code if there is no mutation. For eg. I have enrolled for the proglang course[1] on coursera and only yesterday I completed this weeks homework which involves enhancing an already written game of Tetris in Ruby. Major part of the assignment was about reading and understanding the provided code that uses OOP and makes heavy use of mutation. It was quite difficult to understand what one method does without having a picture of the current state of the object, specially with side effecting methods that call other side effecting methods. A few times I had to add print statements here and there to actually understand which one is being when and how many times. While I could score full marks in the end, I am still not confident about completely understanding the code and have a feeling that if I ever need to work with it again, the amount of time it will take to load up everything again into my mind's memory will be equal to what it took for the first time.

Of course, one could only make a true comparison by studying an implementation of Tetris written in FP style. But from my experience with reading and writing code in Erlang (for production) and Racket, Clojure (as hobby) I find it relatively easier to study functional code written by others.


Nov 11, 2013 · ojbyrne on Amazon Code Ninjas
Oh god. Don't they realize that "ninjas" was replaced by "badasses" around 2011, officially supplanting "rockstars" (which first appeared in 2009).

There is no indication of what language is expected, but presumably it's java, because companies that do this shit, are entirely java.

I feel the urge to click on the button, but I've been doing Dan Grossman's Programming Language MOOC ( lately, so I'm all about functional programming languages, which I suspect this particular programming test does not grok.. and the button looks like it's entirely about product managers and their conception of what programmers do. Which rhymes with "fuck you."

No Racket, no ML

But Haskell, Clojure, Scala, Erlang, Common Lisp... Very far from "just Java"

They're actually using InterviewStreet to do the testing, which supports a variety of languages (including a number of functional ones).
No wait, the real heroes are the Purple Squirrel.

I'll take "Shit HN Says" for $500, Alex...
What about Jedi?
No, they want people who go in silently, fix something and leave the same way. Thus, Ninja.
Wow, it's not that cool to just be a hater and see yourself as a 'sick' engineer that doesn't have time for PM's bull... This is actually a pretty cool exercise, and for someone like me, coming out of school and practicing algorithm interview questions (which are questionable, but hey), this is helpful and fun. Anyways, if all you want to do is say that you are cool because you're learning a functional language and are completely above java, do it in your head.
Sep 27, 2013 · 1 points, 0 comments · submitted by lawn
I am a law major, who did 1 year of engineering a long time ago. I always been a math geek, but 0 in CS. In my last year of college, i created a startup with some friends. It was a ERP for small lawyers firms. That didnt work out, but turned me on into CS.

Now i work as a product manager in a bigger firm (also law related), and i'm learning how to code through Coursera and Edx. I HIGHLY recommend them.

They are the future. The classes are very good. Way better than a regular class over here (Brazil).

If you are intereste in theoretical CS, here are 2 classes that you may be interested:

Programming Languages ( It focuses on functional programming. The first edition was VERY high recommended. Here you will learn about functional paradigm, and the differences in using it in several languages (some purely functional, like SML, some hybrid, like Ruby)

Automata ( It cant get more theoretical than this. The professor is Jeff Ullman. A legend. For free.

Machine Learning: A second version of Andrew Ng just ended. The third edition will be offered soon. is also a very nice place to learn. They are actual stanford classes taped, and offered for free, online. I`m taking the three introdutory classes, and the machine learning classes.

Also, there are several architecture, compilers and algorithms classes too. After my first course (, i realized that colleges (at least for CS) are redundant right now. They can be awsome. But, if you are short of money, or are already working, these online classes can fill the gap, easily.

add me on skype if you want to talk about more classes: lucasribeiropereira

See you!

PS. They can be VERY challenge. Take one, at most two at a time. 10-20 hours per week per course is a good rule of thumb

Aug 28, 2013 · 4 points, 0 comments · submitted by luu
A recent version of programming languages survey class available to anyone is the Coursera class on Programming Langauges from Dan Grossman:

It will be taught again in the fall. He covers three languages (SML, Racket, and Ruby) in ten weeks, hitting three of the four quadrants on strongly typed/dynamic and functional/object oriented.

I've been taking the Programming Languages course on Coursera, the motivation for the course is exactly what you're talking about. "Syntax doesn't matter" has become something of a catchphrase in the lectures, emphasis is always on semantics and how different languages accomplish the same/similar things.

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.

I'm having a hard time keeping up with all these awesome classes.

Coursera's PL class is starting in a few days:

Brown's Intro to PL class:

Sep 20, 2012 · 1 points, 0 comments · submitted by rohshall
HN Academy is an independent project and is not operated by Y Combinator, Coursera, edX, or any of the universities and other institutions providing courses.
~ yaj@
;laksdfhjdhksalkfj more things ~ Privacy Policy ~
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.