Welcome, this is the website where you can buy the PDF for my new book, Functional Programming, Simplified — Updated for Scala 3.
A Whole New World
Wow, a LOT of things have changed since the 1st Edition of this book was released in December, 2017. In fact, back then these technologies didn’t even exist:
- Scala 3
- Cats Effect 3
Therefore, it’s time to update one of the most popular and highly-rated functional programming (FP) books of all time: Functional Programming, Simplified.
New Content Every Week
If you’re interested, join me on this journey as I update this classic book to the most modern FP practices and technologies in 2022-23.
You can think of this update process as reading a series of ~125 blog posts that are dedicated to FP. And in addition to covering all that’s new in FP, it will also demonstrate many of the shiny new features in Scala 3.
As the saying goes, never say never, but I don’t have any plans to release the Kindle version of this book until it is nearly complete. (Frankly, creating Kindle releases is a pain.) Therefore, if you want to join me on this journey and read new blog posts every week, this PDF is the way to go.
What You Get Today
What you get with the book today (December 18, 2022) is the first ~40 pages, which have been partially rewritten. Of course there are a lot of holiday things going on in the next seven days, but my hope is to release the first 100 pages of this new book by the end of this week.
As we go along, I’ll also create a Github page where I can share source code with you, and you can report issues and ask questions.
What Will Be New In The Book
Because the 1st Edition was released almost exactly five years ago (December, 2017), there will be lots of new content in this release:
- All the Scala 3 goodies that pertain to FP (opaque types, extension methods, type classes, and more)
- All the code examples will be updated to Scala 3 (and improved)
- The new Scala CLI tool will be used to make it easier than ever to run the code examples
- Greatly improved coverage of functional domain modeling (ADTs, etc.)
- Akka and Futures are out, ZIO and Cats Effect are in
- More coverage of Try, Either, and functional error handling
- Better images and graphics
I don’t know yet how much I’ll get into ZIO and Cats Effect, but I expect to get at least as far as I did in my “Little FP Book,” Learn Functional Programming Without Fear.
(I refer to this book as my “Big FP Book,” because it’s at least three times bigger than that book.)
About This Book
The first version of the book was written as ~125 small lessons. They were like a series of blog posts, where each lesson introduced only one new topic. Readers wrote me to say that they appreciated that:
- The book was written in a simple style
- Each lesson was small, self-contained, and logically led into the next lesson
- I provided links to over 600 resources
- I provided a ton of background detail about ALL the Scala features you need to know to understand FP
I’m glad to say that this new book will be written in the exact same style!
Just like the first book — depending on your level of knowledge and experience — you may be able to read each lesson in 5-10 minutes. And depending on your background, you may also be able to skip many of the lessons.
I could write more about the book, but I’ll leave that up to people who have sent me comments or posted comments on Amazon, Twitter, and LinkedIn.
As of December, 2022, thousands of copies of this book have been sold, and it’s 5-star rated here with 42 ratings, and 4.6-star rated on Amazon, with 171 ratings.
Here’s some of the feedback from readers:
- Your book is fantastic, I can’t find enough words to thank you!
- Best Scala book I’ve read.
- This is a GREAT book!
- I finally understand monads. Thank you!
- I love the writing style and the approach, great job!
- I read this everyday after work and it makes me so happy. Thank you for this amazing book.
- I love the small lessons, they make it easy to read.
- The best $15 spent on a tech book, ever.
- Thanks Alvin for opening the door for this new world.
- Your book was a real game changer to learn FP.
- Very nice explanation. Just awesome.
- Functional Programming Simplified is amazing, thank you for writing this.
- Too bad I can’t grade higher than 5 stars
- Exactly as promised, this book saves you a lot of time
- The best introduction to FP that I have read for people who are coming from an imperative background
- A very concise style that is easy to comprehend
Why I Wrote The 1st Edition
When I first tried to learn FP I felt hopelessly lost. I tried to learn it through books like the well-known “red book,” and as I tried to read that book, it was like the authors were speaking a totally different language — one that I couldn’t understand. They wanted me to do exercises at the end of every chapter, but I couldn’t, because I had no idea what they were talking about.
Frankly, books like that made me feel dumb, like there was no way I was ever going to learn FP.
However, as I would learn in a journey that took me about 18 months, it’s not that the red book isn’t a good book; it’s just that it’s not meant for beginners. It assumes that you already know a fair amount about FP before you even read it. (Put another way, it’s for intermediate or advanced FP’ers.)
Therefore, I wrote this book for beginners, for people like me.
You Could Have Invented FP!
I start with the basics, and each short chapter builds on the one before it. And as you’ll see, one concept naturally flows into the next. After that — just like Sherlock Holmes investigating a problem — you’ll see that each lesson logically follows the previous lesson, and by the time you get to monads, you’ll think, “Of course, this is completely logical. If I was working in the FP field many years ago, I could have discovered monads myself!”
In the book you’ll learn:
- Five important rules for writing FP code in Scala
- Why pure function signatures are much more important than OOP method signatures
- How pure functions work with I/O
- Lessons to simplify recursion
- Partially-applied functions and currying
- Type signatures are covered many times, so your brain can get used to patterns like `StateT[IO,GameState,Int]`
- The proper way to handle exceptions and null values
- Many lessons on for-expressions (which, by the way, lead naturally into monads)
- Domain modeling with Scala/FP
- An introduction to type classes (and why they exist)
- How to handle concurrency
- Visual lessons on collections’ methods like `fold` and `reduce`
- Much, much more ...
The book is organized into small, single-purpose lessons that flow in a logical order. You’ll see how one concept naturally leads to the next concept, and that concept leads to another one, and so on.
Sorry, I don’t have a free preview available for this book yet because I’ve only just started the editing and rewriting process. But because the style will be the same as the previous book, you can get a good feel for what it will be like by checking out this 400-page free preview of the previous book:
I’ll be glad to provide a preview of this book as soon as I update enough lessons for it!
Prefer A Smaller Book?
The PDF version of this book will probably end up being about 1,000 pages long. If you prefer a much smaller book, check out Learn Functional Programming Without Fear, another FP book for beginners that’s only 250 pages long.
Support My Writing
Lastly, if you don’t want a book but would like to support my writing, you can donate $2 or more here at my Ko-fi.com account. (Writing pays about 1/10th of what programming pays.)
All the best,