What do you think?
Rate this book
Grokking Simplicity: Taming complex software with functional thinking
Distributed across servers, difficult to test, and resistant to modification—modern software is complex. Grokking Simplicity is a friendly, practical guide that will change the way you approach software design and development. It introduces a unique approach to functional programming that explains why certain features of software are prone to complexity, and teaches you the functional techniques you can use to simplify these systems so that they’re easier to test and debug.
592 pages, Paperback
First published August 19, 2019
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 45 reviews
March 28, 2022
The material in this book is important, but there isn't enough of it to justify a 550-page book. The bulk of it is repetitive code samples with only small changes in each listing. Line drawings and "dialogs" also bloat the page length.
Worse, though—those are matters of taste—is the prevalence of flat-out useless text:
This seems like a lack of respect for the reader, and reminds me of padding undergraduate papers to meet arbitrary word count requirements.
Worse, though—those are matters of taste—is the prevalence of flat-out useless text:
We've identified two promising cleanups: First, shopping_cart_total, the global variable, is not being read anywhere. Second, calc_cart_total() is a superfluous function. Let's do the cleanup on the next page.
We identified two things on the last page: shopping_cart_total was not being used, and the function calc_cart_total() was superfluous. Let's inline its code into add_item_to_cart(), where it was called.
This seems like a lack of respect for the reader, and reminds me of padding undergraduate papers to meet arbitrary word count requirements.
June 16, 2021
I liked this book as an introduction to functional programming without it being overwhelming.
FP adherents often skip over the reasoning behind the tools and methods they use, which makes it hard for new folks to understand why they are using these unfamiliar abstractions.
Grokking Simplicity runs through a series of scenarios that illustrate the value in FP thinking and architecture. Read it from start to finish and you’ll be in a good spot to take FP into your day-to-day.
Downsides of the book are that it’s painfully slow sometimes (so just skim over the stuff you already know), and the choice of JavaScript as the example language. JS may be accessible to many readers, but the warts of the language show through and in some cases steal the show from the core FP concepts being expressed.
Overall I highly recommend this book, and I actually read and enjoyed the whole thing!
If the examples were in Clojure, and perhaps if the book were a bit more concise, it’d be a complete slam dunk.
FP adherents often skip over the reasoning behind the tools and methods they use, which makes it hard for new folks to understand why they are using these unfamiliar abstractions.
Grokking Simplicity runs through a series of scenarios that illustrate the value in FP thinking and architecture. Read it from start to finish and you’ll be in a good spot to take FP into your day-to-day.
Downsides of the book are that it’s painfully slow sometimes (so just skim over the stuff you already know), and the choice of JavaScript as the example language. JS may be accessible to many readers, but the warts of the language show through and in some cases steal the show from the core FP concepts being expressed.
Overall I highly recommend this book, and I actually read and enjoyed the whole thing!
If the examples were in Clojure, and perhaps if the book were a bit more concise, it’d be a complete slam dunk.
August 19, 2023
While I appreciate that the author tries to present functional programming in a simple way, I did not learn well from his method, which is to present the wrong/complicated/incorrect solution first, and then refactor the code progressively chapter by chapter. The solution gets changed to be more functional in a later chapter, and then that refactored solution gets changed again in a chapter after that, and etc. It may have worked if the refactored code is only a couple lines, but the solutions are long and address large problems such as dealing with a shopping cart. As such, because I am reading and analyzing the code in order to understand it, the initial non-ideal solutions become ingrained in my mind, and it becomes harder to adapt the functional way when it is finally presented several iterations later. (Presenting the slightly refactored solutions to the same problem over and over again also made me too tired to focus on the later iterations.)
July 9, 2021
Probably the best book about programming... that I've read so far... and sadly there weren't many. ;) Nevertheless, it is truly amazing book that explains plenty of topics in a very clear, simple, easy to understand and accessible manner!!! Absolutely amazing. I am very happy to get that recommendation and I would recommend that to everyone.
July 6, 2021
it's a good book, but for beginners
I thought it would cover some more in-depth topics
I thought it would cover some more in-depth topics
May 8, 2021
The author does a great job of defining the role of side-effects in functional code.
He treats them with the respect that they deserve, and he even gives them another name to better reflect their role in code.
The perspective of
- rather having more data than more computations; and
- rather having more computations than more actions;
was an eye opener to me.
However simple it may seem in hindsight, it gives me a better sense of direction when it comes to refactoring code. And for that, I am thankful.
P.S.
The concepts in this book seem to complement Uncle Bob's concepts of "Clean Code" and "Clean Architecture".
He treats them with the respect that they deserve, and he even gives them another name to better reflect their role in code.
The perspective of
- rather having more data than more computations; and
- rather having more computations than more actions;
was an eye opener to me.
However simple it may seem in hindsight, it gives me a better sense of direction when it comes to refactoring code. And for that, I am thankful.
P.S.
The concepts in this book seem to complement Uncle Bob's concepts of "Clean Code" and "Clean Architecture".
December 9, 2023
Very torn on this one. Examples were simple but practical, and the refactoring approach was an engaging and understandable way to introduce a number of functional programming concepts from first principles. It was also a very light/easy read, staying fairly high level, though not so much as to be totally abstract.
In the other hand, it was relatively basic (it says in the intro the target audience has 2-5 years of programming experience), so I had difficulty evaluating the effectiveness of the presentation of concepts that I was largely familiar with. For someone with functional programming experience it may still hold value in presenting a solid foundation and some frameworks/repeatable patterns for reasoning, though the density/pace is lower than desirable for someone with prior exposure.
In the other hand, it was relatively basic (it says in the intro the target audience has 2-5 years of programming experience), so I had difficulty evaluating the effectiveness of the presentation of concepts that I was largely familiar with. For someone with functional programming experience it may still hold value in presenting a solid foundation and some frameworks/repeatable patterns for reasoning, though the density/pace is lower than desirable for someone with prior exposure.
May 29, 2022
Skimmed through this book during the regular book club sessions at work. I've already been working with Clojure, so the concepts weren't new, however, it lets you think about the things you do and make you realize why you do it.
Also interesting to see how you have to make a few things functional in a language like JavaScript for things we tend to take for granted in Clojure.
It was interesting to look at the different architectural patterns and compare them with what you already do vs what you could be doing, and the tradeoffs along the way. Safe to say, I will be coming back to it the more I learn on my FP journey!
Also interesting to see how you have to make a few things functional in a language like JavaScript for things we tend to take for granted in Clojure.
It was interesting to look at the different architectural patterns and compare them with what you already do vs what you could be doing, and the tradeoffs along the way. Safe to say, I will be coming back to it the more I learn on my FP journey!
March 31, 2024
This book provides important and useful mental models for simplifying complex software and making better software design decisions. Some principles introduced in the book can be applied outside of the software context and are helpful for thinking about complex topics in general.
It's noteworthy that this book tends to provide (too) many detailed examples, switch narratives, and keep repeating the key points just to drive the point home. It's important for me to skip a good chunk of pages to maintain a learning cadence that maximizes effectiveness.
Some useful mental models from the book:
1. Distinguish Data, Calculation (pure function), and Actions (with side effects) and focus on rewriting Actions.
2. Immutable Data Practices
3. Stratified Design Principles
4. Call Graph Analysis (frequency of change is the inverse of reusability)
5. Functional concepts and timeline analysis for distributed system
6. Reactive Architecture
7. Onion Architecture and functional architecture
8. First-Class Functions and Higher-Order Functions
It's noteworthy that this book tends to provide (too) many detailed examples, switch narratives, and keep repeating the key points just to drive the point home. It's important for me to skip a good chunk of pages to maintain a learning cadence that maximizes effectiveness.
Some useful mental models from the book:
1. Distinguish Data, Calculation (pure function), and Actions (with side effects) and focus on rewriting Actions.
2. Immutable Data Practices
3. Stratified Design Principles
4. Call Graph Analysis (frequency of change is the inverse of reusability)
5. Functional concepts and timeline analysis for distributed system
6. Reactive Architecture
7. Onion Architecture and functional architecture
8. First-Class Functions and Higher-Order Functions
Read
July 7, 2021A hands on introduction to Functional programming. There is definitely some good stuff in here and I really like the layout and way of illustrating concepts. That said, I found it tedious (way too long, could have been far more concise) and I found it irksome that a book using JavaScript published in 2021 wouldn’t use ES6+ syntax.
February 22, 2023
Grokking Simplicity reads a bit like a video that's been transcribed into book form. That means it repeats itself—each page is like a frame of video where only the most minute change has happened. This level of detail means you'll never get lost as you read, and the core concepts really get drilled into your head via repetition.
But repetition also also carries the expected downsides. The exhaustive treatment of some subjects is, frankly, a little exhausting. But it did give me confidence that any question which arose as I read would be addressed eventually.
The most important consideration before picking this book up is your experience level. It is an introductory book in the truest sense, great for someone just starting their programming journey. With a year or two of experience under your belt, this would make a great, holistic introduction to functional programming and its benefits. More advanced practitioners will be better served by a more in depth book on the topic.
But repetition also also carries the expected downsides. The exhaustive treatment of some subjects is, frankly, a little exhausting. But it did give me confidence that any question which arose as I read would be addressed eventually.
The most important consideration before picking this book up is your experience level. It is an introductory book in the truest sense, great for someone just starting their programming journey. With a year or two of experience under your belt, this would make a great, holistic introduction to functional programming and its benefits. More advanced practitioners will be better served by a more in depth book on the topic.
August 18, 2023
I really enjoyed this book, but I will admit that I skimmed a lot of the javascript-specific stuff. This is because I'm currently interested in the lessons from this book for green-field hobby projects, not a professonal codebase.
Eric Normand has expressed, really clearly, and intentionally, the benefits and framework of writing software in a way I think does minimize key risks and toil compared to adhoc or mutation-heavy programming styles.
I feel slightly insulted by but also appreciate how this book distances itself from the usual academic/functional-programmer-enthusiast messaging, to make it appealing to people who just want to do their jobs in a way that makes their lives easier.
I really appreciate the abstract teachings of the book, of isolating mutation from stateless calculations, of layering software in a way that encapsulates abstractions, and so on. I am not entirely sure the book sells itself to skeptics (if any book even can), but I think it makes its case in a practical way for people open to considering it.
I did skim the javascript-specific pages on working around aspects of the language that make this style of programming difficult, but given that most texts in this area tend to also extoll languages that don't have significant inroads in professional software development, this reminds me a lot of books like Working Effectively with Legacy Code, in that it takes a very pragmatic approach and works with the existing ecosystem it imagines the reader is in, and provides what seem to be effective steps for moving out of it. I do appreciate that Normand spent so much work discussing the kinds of layers one would build to achieve the benefits advocated in the book, instead of books which elide over these interop frictions, causing people to resentfully deal with rough transitional patches while being sold some seemingly-mystical future ideal.
I expect to gain much dividends from that high-level messaging of the book as I think it does enable me to think about my code in a way that minimizes the kinds of complexity that trips me up when writing software, and would recommend it to people who are trying to figure out and adopt techniques that would make code that is more amenable to extension while minimizing unintended consequences.
Eric Normand has expressed, really clearly, and intentionally, the benefits and framework of writing software in a way I think does minimize key risks and toil compared to adhoc or mutation-heavy programming styles.
I feel slightly insulted by but also appreciate how this book distances itself from the usual academic/functional-programmer-enthusiast messaging, to make it appealing to people who just want to do their jobs in a way that makes their lives easier.
I really appreciate the abstract teachings of the book, of isolating mutation from stateless calculations, of layering software in a way that encapsulates abstractions, and so on. I am not entirely sure the book sells itself to skeptics (if any book even can), but I think it makes its case in a practical way for people open to considering it.
I did skim the javascript-specific pages on working around aspects of the language that make this style of programming difficult, but given that most texts in this area tend to also extoll languages that don't have significant inroads in professional software development, this reminds me a lot of books like Working Effectively with Legacy Code, in that it takes a very pragmatic approach and works with the existing ecosystem it imagines the reader is in, and provides what seem to be effective steps for moving out of it. I do appreciate that Normand spent so much work discussing the kinds of layers one would build to achieve the benefits advocated in the book, instead of books which elide over these interop frictions, causing people to resentfully deal with rough transitional patches while being sold some seemingly-mystical future ideal.
I expect to gain much dividends from that high-level messaging of the book as I think it does enable me to think about my code in a way that minimizes the kinds of complexity that trips me up when writing software, and would recommend it to people who are trying to figure out and adopt techniques that would make code that is more amenable to extension while minimizing unintended consequences.
June 1, 2023
Grokking simplicity is exactly what you would expect from it - a book that describes in basic terms what Functional Programming is. What you would probably not expect is it giving you useful skills and tools that can be incorporated in software projects following any programming paradigm.
Even though I feel like it was intended for people with less experience and knowledge than me, I learned a lot. It also sparked an interest in me to continue delving into FP and see what I can find for myself in it.
The downside to the book is that the author tried too hard to simplify reading it to the extent that the expression, “we ran out of space, so let’s continue on the next page” is written more than a dozen times in the book. What was even more abrasive for my experience as a reader was all the repetition, e.g. there would be a chunk of code on one page, and since the page ends after it and the reader needs to turn the page, there would be a “reminder” on the next page with the same chunk of code; there would be section headings that would be repeated as subheadings and then as the first sentence of the paragraph for the section and etc. All this makes me feel like the editor did not weigh in much.
Despite its intricacies, though, I still shall give it 5 stars, because it’s usefulness isn’t lost in its imperfect style.
Even though I feel like it was intended for people with less experience and knowledge than me, I learned a lot. It also sparked an interest in me to continue delving into FP and see what I can find for myself in it.
The downside to the book is that the author tried too hard to simplify reading it to the extent that the expression, “we ran out of space, so let’s continue on the next page” is written more than a dozen times in the book. What was even more abrasive for my experience as a reader was all the repetition, e.g. there would be a chunk of code on one page, and since the page ends after it and the reader needs to turn the page, there would be a “reminder” on the next page with the same chunk of code; there would be section headings that would be repeated as subheadings and then as the first sentence of the paragraph for the section and etc. All this makes me feel like the editor did not weigh in much.
Despite its intricacies, though, I still shall give it 5 stars, because it’s usefulness isn’t lost in its imperfect style.
August 25, 2023
Definitely a beginner's book, and definitely padded out, I didn't mind. The small incremental steps teaching new concepts combined with Javascript examples made it easy to grasp abstractly and then solidify those ideas with with real code. The repetition could be annoying, especially since it was often a verbatim copy, but I found that actually just made it easier to skip. For those to whom the concept were newer, this sort of repetition would probably help.
I wish the concrete examples were provided in multiple languages. In Python or Go would cover large swaths of the industry (though JavaScript is obviously a good call here). I also would have preferred if he used more typical names, or at least mentioned names used in other languages earlier on, so that if I already knew of these concepts by name in another language, I would be able to apply what I was reading to them immediately, rather than have a post-hoc realization and have to sort of read it back with the 'real' name in mind.
I wish the concrete examples were provided in multiple languages. In Python or Go would cover large swaths of the industry (though JavaScript is obviously a good call here). I also would have preferred if he used more typical names, or at least mentioned names used in other languages earlier on, so that if I already knew of these concepts by name in another language, I would be able to apply what I was reading to them immediately, rather than have a post-hoc realization and have to sort of read it back with the 'real' name in mind.
March 9, 2023
The book has a light hearted classroom style approach to the topic of simplifying code through the use of functional programming.
If you are not already familiar with the concept I would highly recommend that you work through the problems. Seeing just how useful pure functions — calculations as the book explains it — are for giving you less to juggle at once will show you how much easier your life as a programmer could be.
There’s much more in here and avoids the math heavy explanations that plague the average functional language introductions. It’s very practical in how it presents the concepts.
If you are not already familiar with the concept I would highly recommend that you work through the problems. Seeing just how useful pure functions — calculations as the book explains it — are for giving you less to juggle at once will show you how much easier your life as a programmer could be.
There’s much more in here and avoids the math heavy explanations that plague the average functional language introductions. It’s very practical in how it presents the concepts.
October 27, 2021
I came into this book having heard of Functional Programming but not having my head around what it was or why some people I respect were so excited about it. I walked away understanding principles and applications. As I went through it, I was able to apply knowledge right away for refactoring, debugging and building better systems. I feel I am a better developer for having read this book. Highly recommend to anyone who has spent time developing production systems.
February 20, 2022
Grokking Simplicity answers this fundamental question, "What is functional programming and how do I apply its principles to make my code better?" It does so in an elegant and entertaining way, walking you step-wise through refactoring troublesome JavaScript website code. The language isn't the important part of this book, but rather it is simply an accessible tool to express ideas. I highly encourage this book anyone interested in making their code easier to understand and maintain.
March 8, 2023
This is one of the better books I've read on programming. It presents functional programming topics in a very simple way.
The downsides are the massive amount of repetition, writing things wrong (sometimes for many pages) before deriving the correct answer, and the lack of depth.
I would recommend this book to any novice programmer, but more intermediate or advanced programmers will find it too simplistic and repetitive.
The downsides are the massive amount of repetition, writing things wrong (sometimes for many pages) before deriving the correct answer, and the lack of depth.
I would recommend this book to any novice programmer, but more intermediate or advanced programmers will find it too simplistic and repetitive.
March 18, 2023
I read this with a book club at work. If you are looking for an introduction to functional programming this both clear AND concise, this is not the book. While there are useful illustrations of functional programming paradigms, the book is clearly inflated to hit a page count. The level of reiteration was unbearable at times. Then again, if you are looking for material accessible for junior-level software engineers, maybe this book is a decent choice.
April 24, 2022
I kept reading this until the middle, at which point I realized that this book is extremely basic, and it's not getting any more complex. Not a bad book, explanations are quite detailed and clear (although conveniently avoided topic of why immutability is important, for example), but I don't see anyone, but junior programmers benefiting from it.
June 26, 2022
If you like to deep-drive on fundamental of functional programming think (in practical way) such as how the mind-set behind the `map` or `reduce`, for example. this book is really help you understand those stuff.
And, I really enjoy this book very much I would say, like I re-learn the whole functional programming world again (and again) but in difference point of view.
And, I really enjoy this book very much I would say, like I re-learn the whole functional programming world again (and again) but in difference point of view.
November 9, 2022
This is a very nice intruduction to functional programming, including some elegant approaches to software design. Now, if you have some experience with functional programming, you can skip quite a bunch of parts, and be warn, it's a bit repetitive for some concepts. But all in all I think it's one of the books I'll recommend for starting programmers.
April 16, 2023
While I did learn certain concepts of functional programming from the book, it must have been one of the most repetitive and bloated software books I ever read. It's hard to imagine why would author choose to punish their readers with such a trudge other than for trying to reach some page count goal.
January 17, 2024
It is a very good book, especially for people who are new to Functional Programming. If I had got five years earlier, I am sure that would have saved many months of mine as I learned all these concepts in different places, and this book took everything and put it into one place in a great way. Thank you.
December 23, 2021
great work! good for novices but also good for experienced programmers who want to clarify the vocabulary that can be used to explain functional programming concepts to other people. not super keen on adopting onion arch but fairly excellent presentation of fp concepts
July 29, 2022
This is definitely one of the best programming books I've read so far. This goes from how to create functions to the basics of how to architect an application.
This should definitely is a must be for new programmers!
This should definitely is a must be for new programmers!
January 10, 2023
It is the best book about FP that teaches you how to apply FP Skills I have never read/heard before in a progressive timeline with code that is easy to understand and great diagrams to improve comprehension.
You end up with solid concepts about how to orchestrate your code 👌🏻
You end up with solid concepts about how to orchestrate your code 👌🏻
Read
April 1, 2021Appreciated this. Notes captured elsewhere.
You should read it if you care about applying functional programming in your corporate job.
You should read it if you care about applying functional programming in your corporate job.
June 29, 2021
Amazing introduction to functional programming!
October 9, 2021
First half of the book is 5 starts, second half 3.
Displaying 1 - 30 of 45 reviews