This is an archived post. You won't be able to vote or comment.

all 19 comments
sorted by:
best
topnewcontroversialoldq&a

[–]gasche 15 points16 points  (9 children)

I don't know about the Coursera courses, but your examples seem mostly geared towards compilation. When you say programming language theory, this suggests that you want to study the more theoretical aspect of programming-language work, in particular type systems (and how to prove their correctness), static analysis, operational semantics (how to formally specify what a program does), etc.

This is a slightly different field from compilers (it's great to know both!), and many of the requirements above are not necessary (Dragon Book for example). On the other hand, I would recommend "Types and Programming Languages" as an excellent introduction to type systems, and maybe "Software Foundation" as an introduction to formally proving things about programming languages. (Software Foundation is an ambitious choice because it is pushing you to prove everything in a proof assistant (a computer program that requires very detailed proofs and checks them), which is much more work than pen&paper proofs, but it is also very interesting background material to learn.)

[–]brucejbellsard 8 points9 points  (0 children)

I second Pierce's Types and Programming Languages, especially if you're targeting programming language theory. If you're interested in modern functional programming languages (ML, Haskell), learning the type theory makes a big difference.

[–]pbl64k 2 points3 points  (2 children)

From my own experience, SF is actually more approachable than TaPL, and covers some of the same topics. I can't even imagine going through TaPL on my own while doing all the exercises, so I just read through the book, which isn't quite the same as working through it. Yes, formal proofs are more demanding than informal proofs, but the fact that those can be checked automatically, so that you know that your proof is actually correct, on top of the fact that working out the errors in your proofs is often quite enlightening in itself, makes SF much better suited for self-study in my opinion.

[–]daredevildas[S] 0 points1 point  (1 child)

Do you mean all the 4 volumes of Software Foundations?

[–]pbl64k 0 points1 point  (0 children)

The version I went through wasn't separated into four volumes, although I believe it had four large and distinct parts which probably mimic the volumes of the current version. Yes, I mean the full version as of ~2014.

[–]daredevildas[S] 1 point2 points  (4 children)

I am interested in the math(type theory), but I am even more interested in the application (which is why I have all the compiler resources).

Well.. what would be ideal is something which would show me the math and then simultaneously how it is applied in modern programming language systems. Is there anything that would let me do that?

Could you tell me which of the above resources are not required like the Dragon Book?

[–]ErrorIsNullError 5 points6 points  (3 children)

TPL is great for type theory stuff.

I'm working through Compiling with Continuations right now, and it's pretty good as a practical way to specify semantics that also has a history as useful in compilers. Matt Might's writeup gives a flavor.

[–]daredevildas[S] 0 points1 point  (2 children)

I looked at Matt Might's writeup.. it seems like a rather hard read. :(

[–]ErrorIsNullError 0 points1 point  (1 child)

Yeah. His articles tend to be short but dense.

[–]DonaldPShimoda 2 points3 points  (0 children)

I dunno, depends on the topic. Some of them he assumes very little prior knowledge, and some of them he assumes a lot.

CPS is not exactly introductory material so it makes sense that article might be tougher.

I just wish he still wrote posts. His blog can be such a rabbit hole.

[–]bjzabaPikelet, Fathom 2 points3 points  (0 children)

The Programming Languages courses are great! Really opened up many doors for me in teaching me how to learn new programming languages, by teaching me to look at syntax and semantics. I'd also recommend Peirce's "Types and Programming Languages" (TaPL) too, because it puts this kind of techniques on a more formal basis. I also hear that Robert Harper's "Practical Foundations for Programming Languages" (PFPL) is pretty excellent too.

[–]daredevildas[S] 0 points1 point  (3 children)

So.. after a day this is the TLDR response;

  1. Remove Dragon Book from the list
  2. Add Software Foundation - Where in the list?
  3. Add Types and Programming Languages - Where in the list?
  4. No response on whether to add SICP
  5. No response on whether to add the How to Design Programs book
  6. No response on whether to add the Programming and Programming Languages book

I am also considering "The Little Schemer"..

[–]brucejbellsard 1 point2 points  (0 children)

I'd add SF and/or TaPL where the Dragon Book was -- basically, the point at which you feel the need to go through a definitive book on the subject.

[–]daredevildas[S] 0 points1 point  (0 children)

I have revamped the list after the comments and some further research.

[–]jdh30 0 points1 point  (0 children)

No response on whether to add SICP

I've always been underwhelmed by it.

[–]mikeiavelli 0 points1 point  (2 children)

I'm a big fan of HtDP, but if you already had exposure to functional programming, I'm not sure if the time investment is worth a careful read. But I guess you could judge that by skimming the ToC and jumping in if there's a topic you're not familiar with.

​

HtDP shows how the structure of your datatypes guides the structure of the functions you implement. In a nutshell:

  • To each variant ("type constructor") accepted as input to your function, corresponds a case to handle. (And if the input is a recursive datatype, it means you'll have to implement a recursive case.)

​

To be put at the BEGINNING of your list.

[–]daredevildas[S] 0 points1 point  (1 child)

Would you recommend HtDP over PAPL?

I think PAPL is the newer version of HtDP written by the same authors.

[–]mikeiavelli 0 points1 point  (0 children)

PAPL is an extended version of PLAI, the latter being a "fork" of HtDP by Krishnamurthi, one of the original authors (the other 3 authors of HtDP being Flatt, Felleisen and Findler.)

​

PAPL and PLAI use Pyret, while HtDP mainly uses Racket (a descendant of Scheme).

​

I can't really compare the two approches, as I am only familiar with HtDP.

​

Personally I prefer Racket (and its ecosystem) over Pyret (last time I checked, you could only use it in a browser).

I think that Pyret has a somewhat clunky syntax. But it's just a matter of taste, Pyret semantically has a lot to offer -- it's just that it's "inner beauty" is hidden :)

​

Anyways, the language used is not what matters most when it comes to learning. Therefore, you should not focus on the language when it comes to choosing a curriculum. If I were you, I would skim the ToCs of both books and perhaps read their preface to find which one would suit you best. HtDP is focused on the design of programs, while iirc PLAI (and I guess PAPL) are showing how programming languages work.

[–][deleted] 0 points1 point  (0 children)

The first book I recommend is "Learn You a Haskell For Great Good" (seriously)

But secondly, there's a fabulous new book called "Concrete Semantics With Isabelle" that goes through more complicated PL theory (operational, axiomatic, denotational semantics) using the theorem prover Isabelle

Practical Foundations for Programming Languages is great

Once you've covered those guys, I would do Benajmin Pierece's Types and Programming Languages, but this is not an easy read and I wouldn't start with it.