Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. The book guides. Summary. Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. The book. Learn Scala By Examples. Contribute to awantik/scala-programming development by creating an account on GitHub.
|Language:||English, Spanish, Dutch|
|Distribution:||Free* [*Registration needed]|
Functional Programming in Scala book. Read 51 reviews from the world's largest community for readers. Functional programming (FP) is a programming style. One thing I dislike about the Red book (Functional Programming in Scala / Chiusano is that it is missing most of the answers to the exercises. Functional Programming in Scala Specialization, free on Coursera. The book provides both an authoritative reference for Scala and a systematic tutorial.
There are other books, such as Joshua Suereth 's fantastic Scala in Depth , 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! 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. The pacing of the book is very good as well. Another reason for this, is that the book is written in such a way that the practical use of every concept is made clear before the theory behind the concept is explained.
The best part All that being said, the highlight of the book for me was actually this: Look! The key insight for me, is that functional programming is all about how far we can take DRY. Turns out: pretty damn far.
And because mathematics discovered them before programming did, they ended up with meaningless, off-putting names like monad and applicative. But in the end, these things are just design patterns and no more complex than, say, Visitor. Does that mean I will start using category theory in the Scala code I write at work? But I am much more likely to start experimenting with something like Cats in my personal projects now.
Knowing Scala is useful but not required. All important concepts like monads, applicative functors and traverses are introduced in natural way as useful solution for common problems. Exercises are well formulated and extremely helpful.
Important note: It's just giving you bare minimum to understand the concepts, not the full power of language. 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.
Here is my favorite description of functional programming given by Tony Morris: 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. Composable programs scale indefinitely, by composing more and more sub-programs. 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. Moreover, you should do yourself a favor and also take into account the extra reading at https: Depending on your level of Scala, e. 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.
Mar 12, Michael Koltsov rated it really liked it. This book has an outstanding goal — teaching FP principles to those who might have close to no experience with functional programming. Fortunately, this book delivers that what it has promised. Since starting to read I understoo This book has an outstanding goal — teaching FP principles to those who might have close to no experience with functional programming. Since starting to read I understood a lot of concepts that previously I thought of as too complex for me which made my life a lot easier and my code better.
Besides these chapters I got lost trying to digest some of the concepts that this book has tried to teach me. Apparently that has something to do with the amount of exercises you need to complete to make a progress with this book. Authors need to grasp more teaching experience to make their book easier to comprehend and get rid of some useless exercises but keep all the important ones.
Feb 24, Pradeep Kumar rated it it was ok. Unreadable, especially in the most interesting parts. The exercises would have been better if their solutions followed immediately.
As it is, the book demands too much from its readers. May 06, Rutvik Patel rated it it was amazing Shelves: Content of the book is extremely dense and authors have often been reminding - almost in every chapter since part I - "Don't worry too much about following absolutely everything in this section" and it's pretty much assuring.
Exercises are the key elements.
Its a part of the content so don't leave it, otherwise you are going to be stuck in sections to come. Here is a quote from chapter I "Functional programming is based on a simple premise with far-reaching implications" and authors have succeeded in showing that it is the case. I have enjoyed the book immensely and sometime felt annoyed, of course because of my limitations of understanding the material.
But the formula is - keep reading - if you get stuck on some section, put it down and read it again after couple of weeks. Book will make you a better programmer that's guaranteed. I've started rereading this again and was just reminded of one of things I most detest about this book: I will not do these and if you cannot communicate clearly what you are trying to without these exercises, then I do not believe you have done a good job.
Jan 21, Sebastian Gebski rated it it was amazing. I've read it all wrong.
And I'm the one to be blamed for that. And believe it or not these exercises are the biggest value addition, much more than the descriptions. Some exercises are really hard and I've read it all wrong.
Some exercises are really hard and require a lot of time and understanding of what you just read - unfortunately I didn't have time for that, but that's something I'll definitely returning to in future.
It's not a bunch of practical examples you'll fly by. Be warned - if requires a given type of mindset and a proper patient approach. You have to acknowledge the points above if you're about to read this book.
If you accept these, you'll love the book - it's absolutely brilliant. Otherwise, it may still be very valuable, but you won't be able to benefit fully from it. Dec 11, Hang Zhao rated it it was amazing.
Finished the 12 edition. Although I still need to go through it several times to get some of the harder exercises. I fill this book will be a classic. The first 6 chapters are great to get a mood and idea of Functional Programming and how to do it in Scala. Then you get into real life libraries to get the power of Functional Programming. Chap 15 then will show you how to do Streaming Processing which is really hot topic with "Machines". The book though is pretty slow in the sense of showing things, jumping over chapters will not make you lost, but will impair your understanding of abstract concept as a lot of them can only be understood with multiple concrete examples Aug 20, Juan Ignacio rated it it was amazing Shelves: A must-read if you want to get the most out of Scala functional capabilities.
In order to get from the premise to the final implementations it uses a nice incremental approach where every step is both useful and meaningful. It's as concise and to-the-point as it can be, which also makes this a really dense book. I'll keep revisiting it for a long time, in order to grasp its concepts by rereading and doing every exercise.
Aug 26, Tomasz Bartczak rated it liked it Shelves: It was a very challenging book.
The material in there is really vast and well prepared with tons of exercises. FP makes you think in a different way, and that's hard to accept at first.
After finishing this book I know more about FP but seeing a bigger picture I know there's more to uncover than I initially thought. Apr 21, Steven Shaw rated it really liked it. 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! Oct 06, Eileen Sauer rated it it was amazing. Haven't understood all of it, it's pretty dense but it's doable when you go through Martin Odersky's Coursera course on Scala. Feb 06, Ovais Mohammad rated it really liked it.
This is one of the best book to learn typed functional programming. I found it to be even better than some of the books available in Haskell. This is quite helpful in understanding laziness. We learn to discover the minimum set of primitive operations required for each of these libraries. We understand that why we need laws for the operations library will support and identifying the minimum set of laws.
In exercises it then showcases this problem of monads understanding by asking the reader to explain in words what monad operations do in different contexts. I found most of the exercises quite approachable and at the right level of difficulty needed to grasp the concept.
This gave me an opportunity to see how well I can learn complete new topics from this book. It turns out that apart from some parts of last chapter I was able to follow through without much difficulty.
However, I think last chapter could be improved to make it more approachable.