It's clear that a lot of love for the subject went into the making of the book. I thought I knew functional programming pretty well but I was humbled and learnt a lot. The additional notes on the fpinscala wiki all well worth the read. I still have a lot of fascinating things to follow up! ( )

It is safe to say that “Functional Programming in Scala” by Chiusano and Bjarnason can be considered the most advanced Scala programming book published so far (in a sense, it can be compared to SICP.). Half of one of my bookshelves is occupied by Scala books, including Scala in Depth, but none of them takes the concept of functional programming as serious as this book, and pushes it to its limits that much. This, in turn, means that most of the Java programmers (including very senior ones), as well as Scala programmers with some experience should prepare themselves to feel very much like a newbie again.

But why the need for such a book, and what’s all that noise about functional programming? Here is my favorite description of functional programming given by Tony Morris : “Supposing a program composed of parts A, B, C, D, and a requirement for program of parts A, B, C, and E. The effort required to construct this program should be proportional to the size of E. The extent to which this is true is the extent to which one achieves the central thesis of Functional Programming. Identifying independent program parts requires very rigorous cognitive discipline and correct concept formation. This can be very (very) difficult after exposure to sloppy thinking habits. Composable programs are easier to reason about. We may (confidentally) determine program behaviour by determining the behaviour of sub-programs -> fewer bugs. Composable programs scale indefinitely, by composing more and more sub-programs. There is no distinction between a ‘small’ and a ‘large’ application; only ‘smaller than’ or ‘greater than’.”

The description above not only points at the core idea of functional programming and why that is important, as well as useful, but also draws attention to the fact that getting used to functional programming design can be difficult for people who are not used to thinking that way. Fortunately, “Functional Programming in Scala” is here to fill a huge void in that respect.

The book can be considered one of its kind, not only because of its strong logical foundations, starting from first principles and rigorously following them to their consequences, but also for its pedagogical approach. Even though it is aimed at practicing programmers and not academics, every chapter includes a lot of exercises arranged in a very nice developmental manner. But make no mistake, this also means that you cannot simply read that book, you can only study it. This, in turn, means that the only way to read the book is to run your favorite Scala coding environment, grab the exercises’ source code (and in case you are stuck, hints, as well as answers) from https://github.com/fpinscala/fpinscala, and start solving the exercise by implementing the required functions and other stubs. Moreover, you should do yourself a favor and also take into account the extra reading at https://github.com/fpinscala/fpinscala/wiki.

Depending on your level of Scala, e.g. if you have successfully completed the Coursera course titled “Functional Programming Principles in Scala” by Odersky, you can finish the first few chapters and exercises relatively quickly, but I would suggest to take your time after the first few chapters, 1-2 weeks per chapter will probably be an adequate pace for experienced programmers.

I can recommend this book to serious, curious, brave,and open-minded developers who target JVM by using Scala, and want less duplication, less boilerplate and much more powerful abstractions that are also easier to reason about, and who are ready to invest time to slowly digest the material by doing exercises instead of trying to quickly skim the text. ( )

This book should be required reading for anyone wanting to really learn and understand Scala. It's not that the book will necessarily give you mastery of the language -- only time and experience gained through writing lots of code can do that, though they help by giving the reader lots of good exercises. But it will alter your view of the language and very likely teach you a new way of approaching problems. The authors are both expert Scala engineers with deep understanding of the principles of functional programming. Their approach is illuminating, in particular, in showing how you can apply the type system and referential transparency to solve problems using very generalizable patterns.

Addendum to my earlier posting of this, initially very brief, review:

First, it's worth noting that this book in no way requires you to learn or use Scalaz, though both authors are contributors to that library. It will teach you what you need to better understand Scalaz, but it also leaves a lot out. For example, the current pre-release draft of the book doesn't even mention type classes. In my opinion, this is a good thing. There are other books, such as [a:Joshua Suereth|4849384|Joshua Suereth|https://www.goodreads.com/assets/nophoto/user/u_50x66-d9f6a4a5badfda0f69e70cc94d962125.png]'s fantastic [b:Scala in Depth|11353552|Scala in Depth|Joshua Suereth|https://d202m5krfqbpi5.cloudfront.net/books/1367918492s/11353552.jpg|16283389], that do a very good job of this already. And covering this material here would only take away from the core of what this book attempts to teach.

Finally, I should note that I was both a technical reviewer of earlier drafts and did the final technical proofreading. So hold me responsible for any errors that slipped through!! Well, not really! ;~) I was (well, will be) compensated for both of these (a free book in the first case and a small monetary amount in the second), but I can tell you truthfully that in no way did this influence my review of this book. If anything, my experience proofreading this gave me an interesting insight into the book. Having tech reviewed and proofread many other books, I was floored by how few technical errors (remember, I was not reviewing their language or grammar) I was able to find. I personally believe this may demonstrate something interesting about the diligent effort the authors put into this book.

Additional notes:

This book is a good one to work through with others, particularly given the exercise driven nature of it. At Janrain, where I am currently employed, we started a study group to work through it. We initially planned a week per chapter, but found even this was overly aggressive at times. It's best to find the rate that works for the group and adjust as needed.

As I mention in one of my comments below to my friend and coworker Sean, this is probably nto the best book to use as an introduction to Scala. The authors do a good job of introducing the features you need to work through the book (though I did see a few places where they leave the reader to find more on her own), it won't give you the breadth you really need to become proficient. That said, if you do choose to pick up a book, such as [b:Scala for the Impatient|11335855|Scala for the Impatient|Cay S. Horstmann|https://d202m5krfqbpi5.cloudfront.net/books/1348110005s/11335855.jpg|16264400], you can certainly work through both in tandem if you're really in a hurry.
( )