Functional programming books review
alexott.net
alexott.net
A lot of the stuff there is to know about functional programming is still only contained in academic papers, and indeed many of these listed books are texts in programming languages that cite a great deal of the important literature. There is much about programming languages and functional programming that one might read interspersed with these books. Other than following references in the backs of many of these books, the Haskell wiki is a good place for starting to dig into literature on functional programming, as many articles link to important and interesting papers.
On that note it's a bit strange not to see a few books on semantics, such as Transitions and Trees or Semantics Engineering with PLT Redex, listed among books like TAPL and Barendregt's Lambda Calculus. Especially now that DSL design is something many programmers are dabbling in, it makes sense to gain some background on operational semantics. I'd recommend either of these books to anyone working on DSLs, especially in a functional language.
Finally, it might be worth adding Homotopy Type Theory to your list, especially since the list already contains several good books about Coq as well as works about type theory and type systems.
http://www.haskell.org/haskellwiki/Fold
http://www.haskell.org/haskellwiki/Monad
http://www.haskell.org/haskellwiki/All_About_Monads
http://www.haskell.org/haskellwiki/Learn_Haskell_in_10_minut...
http://www.haskell.org/haskellwiki/Typeclassopedia
Also check out http://adit.io/ for some great tutorials with pictures
1. http://adit.io/posts/2013-04-17-functors,_applicatives,_and_...
Which is definitely a point on the side of "has no impact".
But on the other hand, I think studying dependent types is a fantastic way to get some perspective as an intermediate to advanced Haskell or OCaml programmer. Software Foundations and Certified Programming with Dependent Types are both great books to read.
HoTT won't be on that list for some time if ever, but once you've got a good mental model for dependent types it's illuminating to see them worked out "from scratch" as HoTT does.
So, the best I can say is that it can be influential in the way that you view types if you're someone who frequently programs and thinks in a nicely typed language like Haskell/OCaml and maybe Scala.
I would argue that the book is at least as useful as Categories for the Working Mathematician or Barendregt's Lambda Calculus are likely to be for your typical software engineer interested in functional programming. To be clear, someone interested only in learning how to program in functional languages is probably not going to get very much from either of those books, which are respectively an extremely technical mathematical text on topics in category theory, and a heavily logic-oriented, mathematical presentation of the lambda calculus and derivatives thereof. Not much of the material in either book would be directly applicable to the practice of software engineering using functional languages, but someone with a deeper interest would find them useful and interesting, and I think the same holds for the HoTT book. At the very least, as the other commenter alluded to, a novice reader would probably be able to glean a nice understanding of Martin-Löf dependent type theory from the first chapter.
Also, the ordering of books is best done in reverse chronological order. Improvements are made in different compiler versions so it would cause frustration for a new reader if they come across a disconnect. I suspect the same is true for other languages listed. The most recent books are 'OCaml from the very beginning' [1] (released earlier this year) and 'Real World OCaml' [2] (released a few weeks ago). You can find these and other OCaml books listed at: http://ocaml.org/learn/books.html
http://learnyousomeerlang.com/
It can be a bit verbose if you just want a reference, but that's because he spends so much time teaching you the details.
(1) Prolog Programming for Artificial Intelligence (first half is sufficient to start) -> (2) The Art of Prolog -> (3) The Craft of Prolog
As a first "get to know the language" I'd add:
http://www.amzi.com/AdventureInProlog/a1start.php
You build a basic old-school text adventure in Prolog which is more accessible than the traditionally boring introductions with family databases (imo). It's from amzi but should work with most Prologs, iirc I ran through it with GNU-Prolog (I'd recommend SWI though, it's the best open source implementation out there imo). Uses some metaprogramming that is usually not covered in introductory material (and often considered "use with care") i.e. dynamically updating code with assert/retract
I have only browsed "Warren's Abstract Machine: A Tutorial Reconstruction" but it's on my to read list. Interesting for anyone that enjoys VM-design and the like.
I cannot recommend it enough.
We are mostly working on Martin Odersky's Coursera courses and SICP book exercises.
We have also revived the FP meetup in Singapore. Drop me a line, if you are interested, dear reader. (Email in profile.)
I saw some really great videos there about concept of programming and data structures.
{pretty impressed}
And oh look, the Amazon articles are tagged, which means the author gets affiliate compensations. And what do you know, it's the hollyday season, so people buy stuff on Amazon.
And don't get me wrong, I'm fine with that, I did it myself, but at least read the freaking books that you're recommending, before recommending them.
P.S. About affiliation links - it's written clearly in the 2nd paragraph of the page.
$ curl http://alexott.net/en/fp/books/ 2>/dev/null | \
grep -o 'http://www.amazon.com/gp/product/[a-zA-Z0-9]*' | \
sort -u | wc -l
132
(2) I'm seeing books that have been OK-ish when they appeared and thus recommended by people, either because of lack of other choices, but also because the advice contained was the status quo, but right now are pretty bad choices. "Programming Scala", by Alex Payne, for example is an awful reference to put on any list of books for Scala. It contains bad practices, plus lots of references to obsolete parts of the standard library, not to mention its general flow is just awful. If you would have read it, you would have known. "Programming Scala" the one published by the Pragmatic Programmers, is another awful choice. Actually, all books on Scala published before 2010 are awful choices.
(3) What the hell does a book on Scalatra has to do with Functional Programming? Is it because the association with Scala or something?
(4) It's bad advice to tell people to buy books from Amazon. The E-Books are DRM-enabled Kindle versions, sometimes badly formated and you don't get the PDF. Many of those books have the same price if you buy straight from their publishers and you get both a DRM-free Kindle version and the PDF.
if you look to the page more precisely - it has a separate section, called Recommendations where only some of books are listed.
Regarding the Amazon - the 2nd paragraph clearly says "if possible" - nobody forces you to buy books from amazon!
But lets be generous and say that 2 weeks is the average for reading a technical book. And there are on average 52 weeks in a year.
132 * 2 / 52 = 5.08
Also, the section on recommendations is shallow. It references books for getting started, after which it gives advice to continue with the books above. And I'm not seeing negative remarks on the referenced books at all. Everybody has opinions on whether a book was good or not. What kind of review doesn't do that?
"Functional Programming in Scala" is an awesome book on functional programming btw. You should put that as a recommended book.
I've heard about "FP in Scala" and it's loaded into my kindle prepared for vacation (together with many other)...
At the very least, you could mention which and why.
There's a hell of a lot more value in...
"The ZINC experiment: an economical implementation of the ML language is a technical report, written by Xavier Leroy (author of OCaml) in 1990th, and it contains pretty detailed description of ML-like language implementation. This report could be very interesting for all who wants to know about internals of Caml & OCaml languages."
...x 132 from someone who may or may or may not have actually read what's linked than a simple "awful" without any context or qualification.
I mean, you could have just dropped a link to your own site and added something of value, instead of creating a nonsense tangent of accusation:
https://www.bionicspirit.com/blog/2013/05/13/getting-started...
What you're doing is a direct ad-hominem btw. I don't need qualifications to infer that it's impossible for somebody to read 132 books on some of the hardest topics in CS. We also have different definitions for what "value" is.
I've compiled this list long time ago as an article for Russian FP journal, and it takes relatively much time to track new books, obtain them (paying myself or get through Safari Online), read or at least briefly go through it, and write a short review...
P.S. regarding the referral money - don't think that it generates a ton of money - it's barely enough to buy one inexpensive book per year...
About 2/3rds of people follow the referral link.
Out of the several thousand pageviews and several hundred clickthroughs, I've accrued a grand total of about $60.
Unless you have thousands of clickthroughs, or you spruik products with high impulse value, Amazon referral links are not very lucrative.
I can recommend Functional JavaScript by Michael Fogus.
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".
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.
I look at their exercises more from a "I'll do it until I feel I have learned the core concepts" rather than "I'll do it until the grader gives me 100%".
If you're not taking the course for credit, your goal should be learning, not grades. That's what it's all about for me, and learning reactive/functional/Scala programming has little to do with debugging a black box of a grading system.
(Totally agree for those people who paid to receive credit, it must be very frustrating at times)
If the grader is marking you off on a certain aspect of the assignment, how do you know you have actually learned the core concepts? How do you know you aren't missing something important? The problem with "doing it until I feel I have learned the core concepts" is that I don't know what I don't know (unknown unknowns). That's part of why a structured course is supposed to be valuable, because it doesn't let me skip important concepts.
This course can be salvaged the second time around, but it is going to require a bit of polishing.
Hard, yes, but fantastic.
You have to be prepared to put in the hours that the course says you should put in, and you have to be prepared to spend a lot of time reading about other people's confusion on the discussion forums.
Seeing the absolute beginners stuggle is painful, but at least they are making an attempt.
Btw, the craziest coursera forms I ever saw were in the non-tech fields. In Into to Finance it was so bad; at least our sort don't type posts in all caps ;)
While Lisp can be used in a functional manner, the book does not really qualify as a book on functional programming.