What do you think?
Rate this book
Functional Programming, Simplified:
Sale! The price of this best-selling, highly-rated functional programming book is normally $15, and it is temporarily reduced!While he’s known for writing two editions of the Scala Cookbook for O’Reilly and the Scala Book for the official Scala website, this book is his most popular, helping thousands of developers to understand functional programming (FP). He does this in a simple writing style that focuses on a series of source code examples (rather than abstract programming concepts like functors, monads, and category theory). As a former teacher of Java and object-oriented programming (OOP) courses, it’s just as though he was pair-programming next to you, or mentoring you in a small classroom.In this classic book — which is one of the highest-selling FP books of all time — Functional Programming, Simplified makes the process of learning functional programming in Scala (what he calls Scala/FP) as simple as possible by breaking down complex topics into small, bite-size chunks that are easy to understand.Through a lot of pain and frustration, Mr. Alexander learned that if you learn Scala/FP topics in a logical sequence — the sequence he shares in this book — it’s much easier to learn FP. (Conversely, the reasons that many developers can’t understand FP is that there is some gap in their knowledge that keeps them from making the conceptual leap from one topic to another.) Therefore, the chapters in this book are small, one-topic lessons, where the piece of knowledge you’re learning in the current lesson is exactly what you need to be ready for the next lesson.The book’s lessons simple set of rules for functional programming in ScalaHow and why to write pure functions and use immutable variablesWhy function signatures in FP are *much* more important than method signatures in OOPHow pure functions work with I/O (file, database, and network)How to read anonymous functionsLessons on recursion, with many images to help explain how it worksHow the concepts of JVM stacks and stack frames workPartially-applied functions and curryingHow using Option naturally leads to flatMap, and how flatMap naturally leads to for-comprehensionsSimple, useful definitions of FP concepts like functors and monadsHow to write your own monad!How to use other monads like State and IOHow to use monad transformers like StateTDomain modeling in functional programmingHow to use “lenses” to update immutable data modelsConcurrency lessons cover Akka actors and Scala futuresVisual lessons on collections’ methods like fold and reduceHow to use the ScalaCheck property-testing frameworkHow to write and use “type classes”Algebraic Data Types (ADTs) are explainedAll told, the book contains 120 small chapters. Source code examples from the book are available as a series of Github repositories that you can download and work with.
1098 pages, Kindle Edition
Published October 17, 2017
149 people are currently reading
256 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 20 of 20 reviews
August 7, 2018
Fantastic resource for those who are terrified of monads and functors yet know basics of Scala and functional programming.
Alvin Alexander is an incredible author who believes learning functional programming doesn't have to be a pain. The book is written in a very simple language, reading it is nearly like chatting to a really good friend. I giggled at some of the puns! Also - there is memes, it makes reading this book a pure pleasure. I in fact did read the first 10 chapters or so sipping my tea.
What's so outstanding about the book?
Two things.
Thing number one: chapters are very short. It's so easy to chunk the workload. Also, doing 3 chapters in one day sounds like you're making great progress.
Thing number two: His explanations often at first don't mention "scary" words such as monad or functor but instead what he does is:
1. Show reader a problem, get a reader to think of how they'd solve it
2. Know your reader doesn't know fp principals and show them their solution likely isn't functional
3. Show them a functional-ish solution that will be very easy to grasp
4. Build on 3. and show them a pure functional solution that's more difficult yet still logical and clear to understand
5. Tell them something along the way of "Ah, by the way, you just implemented a scary functor. Wasn't bad now, was it?"
6. Reader's jaw dropped
100/5, there is just not enough stars for this book.
Alvin Alexander is an incredible author who believes learning functional programming doesn't have to be a pain. The book is written in a very simple language, reading it is nearly like chatting to a really good friend. I giggled at some of the puns! Also - there is memes, it makes reading this book a pure pleasure. I in fact did read the first 10 chapters or so sipping my tea.
What's so outstanding about the book?
Two things.
Thing number one: chapters are very short. It's so easy to chunk the workload. Also, doing 3 chapters in one day sounds like you're making great progress.
Thing number two: His explanations often at first don't mention "scary" words such as monad or functor but instead what he does is:
1. Show reader a problem, get a reader to think of how they'd solve it
2. Know your reader doesn't know fp principals and show them their solution likely isn't functional
3. Show them a functional-ish solution that will be very easy to grasp
4. Build on 3. and show them a pure functional solution that's more difficult yet still logical and clear to understand
5. Tell them something along the way of "Ah, by the way, you just implemented a scary functor. Wasn't bad now, was it?"
6. Reader's jaw dropped
100/5, there is just not enough stars for this book.
October 20, 2018
Finally, a book that teaches functional programming in an easy and approachable manner. Such sources are very rare. The author went through a lot of books and articles and put together a single resource for us - mortals - to learn functional programming properly. He explains FP-related vocabulary that sounds intimidating when you first encounter it (especially if you have no extensive math or FP background). Every basic aspect of functional programming is dissected, described and shown in multiple examples. It will make you wonder why you thought functional programming is difficult.
Note: All code examples used throughout the book are written in Scala. In order to be able to use this book, you should know at least the basics of Scala and have it set up on your machine to run the code on your own or try to do the exercises.
Note: All code examples used throughout the book are written in Scala. In order to be able to use this book, you should know at least the basics of Scala and have it set up on your machine to run the code on your own or try to do the exercises.
November 20, 2017
Most enjoyable book I’ve read by far. Simple, intuitive and very detailed, FP Simplified (Scala ed) covers everything you’d ever ask about Functional Programming paradigm. The author guides the reader through concepts in a way the reader will get the point. Then, he names the concept explained how it’s known as.
I don’t recommend this book for people who don’t know Scala, though. I’d suggest to read some of Scala lang before read this one.
I don’t recommend this book for people who don’t know Scala, though. I’d suggest to read some of Scala lang before read this one.
July 30, 2018
This book explains the main concepts that are needed to understand Functional programming in Scala. I recommend it to beginning Scala programmers who want to learn about functional programming.
Pros:
Covers the basics of functional programming (Scala) very well.
Small, easy to follow lessons.
There are lots of code examples, even more given on the author’s github pages.
Monad chapters are good for learning their basic usage.
Cons:
Sometimes I felt more like I am reading a blog post rather than a book. I can’t explain why. One reason may be there are way too much quotes from other authors’ books, blogs, etc. in almost every chapter. It’s not bad, but I found it a bit unusual in a book.
After completing this book I am feeling confident to start reading “the red book” (FP in scala) again.
Pros:
Covers the basics of functional programming (Scala) very well.
Small, easy to follow lessons.
There are lots of code examples, even more given on the author’s github pages.
Monad chapters are good for learning their basic usage.
Cons:
Sometimes I felt more like I am reading a blog post rather than a book. I can’t explain why. One reason may be there are way too much quotes from other authors’ books, blogs, etc. in almost every chapter. It’s not bad, but I found it a bit unusual in a book.
After completing this book I am feeling confident to start reading “the red book” (FP in scala) again.
September 26, 2018
One of best books I've ever seen for the newcomers in FP
Read
June 24, 2024Note 1: I've actually finished 2nd edition, but I don't think there's a separate page for it yet
Note 2: 2nd edition is still WiP, while most of the book is there, one chapter is absent, and there are few minor errors.
Leaving this one without a rating. Not very useful for me as it's really aimed at people who are unfamiliar with Scala, or use it plainly as Java. It won't make a type astronaut out of you, but would give some understanding of how FP code should look like.
What I found missing is actual real-life applications that were promised in book's description - FP looks nice and rosy while you're explaining it on small examples, but becomes much trickier once you need to write something real, even a simple CRUD - couple of REST endpoints, talking to DB etc.
Maybe it will be touched on in the missing chapter, but at this point it's not there.
Note 2: 2nd edition is still WiP, while most of the book is there, one chapter is absent, and there are few minor errors.
Leaving this one without a rating. Not very useful for me as it's really aimed at people who are unfamiliar with Scala, or use it plainly as Java. It won't make a type astronaut out of you, but would give some understanding of how FP code should look like.
What I found missing is actual real-life applications that were promised in book's description - FP looks nice and rosy while you're explaining it on small examples, but becomes much trickier once you need to write something real, even a simple CRUD - couple of REST endpoints, talking to DB etc.
Maybe it will be touched on in the missing chapter, but at this point it's not there.
September 28, 2018
This blog-like book is possibly the gentlest introduction to functional programming ever. Note: it's really for absolute beginners to functional programming. That said, I liked Alvin Alexander's approach to introduce FP from the point of view of experienced (and sceptical) procedural/object-oriented programmer. Gradually, FP concepts are introduced, their downsides pointed out and remedies offered. This way the reader learns not only how, but also why various FP strategies look the way they are.
On the downside, I think the book could be shorter by ~200 pages without significant loss of the amount of conveyed information. Instead of many repetitions, it would be better to offer at least a quick glance at algebraic data types.
On the downside, I think the book could be shorter by ~200 pages without significant loss of the amount of conveyed information. Instead of many repetitions, it would be better to offer at least a quick glance at algebraic data types.
February 16, 2021
There are many very fine books on learning Scala FP, but this one definitely stands out. It almost reads like a novel. You start with some simple premise and while turning the pages all the advanced functional programming concepts come along without ever scaring you. There are sections on immutability, recursion, monads, for comprehensions, handling state and pure functions, concurrency and above all a very very very instructive part about program organisation (where to put your pure functions) for those coming from an OO background. Read it cover to cover while following a Scala FP MOOC course. Alvin is the Scala man!
April 28, 2020
Quite a fine book. It's clear that Alvin has a mountain of knowledge on the topic. However, to put it short, it's far too long and surprisingly not in-depth enough. It explains what monads and functors are in too much of a "practical" way that it makes it not very easy to generalize these abstractions to anything other than scala. It's a great book to get started with functional programming, but please, make sure it won't be your last or you'll remain with a very limited overview of what functional programming is.
June 17, 2019
A very good explanation of Functional Programming, the books cite and compare so many sources. But most parts of books explain Scala FP features, so if you want to implement the concept using other languages than Scala and you have experience with Scala you can to skip a lot of chapters.
This book also good if you want to know more about Functional Features in Scala.
I hope someday Alvin Alexander will write this book using other Language than Scala such as Kotlin.
This book also good if you want to know more about Functional Features in Scala.
I hope someday Alvin Alexander will write this book using other Language than Scala such as Kotlin.
July 29, 2020
Good read. The explanations of concepts are clear and well written.
Keep in mind is this for people who really are brand new to functional concepts. If you have had any prior exposure to FP, you've probably already covered most of the book.
I would also echo one of the criticisms in previous reviews. The contents could have been greatly condensed and simplified. The book should really be half the size.
Keep in mind is this for people who really are brand new to functional concepts. If you have had any prior exposure to FP, you've probably already covered most of the book.
I would also echo one of the criticisms in previous reviews. The contents could have been greatly condensed and simplified. The book should really be half the size.
October 5, 2022
A very practical and light comprehensive lecture on scala and functional programming. It contains many examples, all very easy to follow along even without an IDE or else. It demystifies concepts such as ADT, functor, monads, etc. The only downsides I can think of are: it assumes you have basic knowledge of scala syntax, and some examples are too simple. More complex's would be nice. But for the latter, the author's website is filled.
January 28, 2021
Achei fantástica a forma com a qual o livro é estruturada: uma infinidade de objetivos pequenos, que tem o problema muito bem definido e a solução bem elaborada. Não, não é um cookbook, os tópicos vão seguindo uma ordem crescente de aprofundamento no paradigma funcional.
October 21, 2024
A highly digestible introduction to functional programming concepts and their implementation in Scala.
Alexander breaks down complex topics into clear, manageable sections, making the book an invaluable reference I find myself returning to often.
Alexander breaks down complex topics into clear, manageable sections, making the book an invaluable reference I find myself returning to often.
September 21, 2018
Good book overall, does not go as far as I wanted initially.
November 24, 2020
the great book for light diving to FP and preparing for hard books
September 3, 2021
crazy book for functional programming style
October 20, 2022
Easy reading and great thought process
Suitable for people who knows a little bit of scala syntax and want to understand FP properly .
Great sources/reference provided
Suitable for people who knows a little bit of scala syntax and want to understand FP properly .
Great sources/reference provided
December 6, 2022
As someone new to Scala and Functional Programming, I found the thorough explanations and measured pace to be just what I needed.
July 26, 2022
Technical content: 4 stars (except the small part about Spark). After reading it I feel I have a better grasp of functional programming concepts and where to go from there.
Style: 2 stars. 900 pages and 130 chapters (without the appendices) for what feels more like reading 130 blog posts copy-pasted in a book, or a draft of a book. It feels to me a lot could have been explained in a much more concise way, maybe with the help of a skilled editor. With a better style the same content likely could be explained in about 300 pages and become a really good introduction to functional programming.
Style: 2 stars. 900 pages and 130 chapters (without the appendices) for what feels more like reading 130 blog posts copy-pasted in a book, or a draft of a book. It feels to me a lot could have been explained in a much more concise way, maybe with the help of a skilled editor. With a better style the same content likely could be explained in about 300 pages and become a really good introduction to functional programming.
Displaying 1 - 20 of 20 reviews