Although many argue that using a functional language eliminates much design, "Uncle Bob" does a great job illustrating that the two approaches are not mutually exclusive, but actually beneficial. Kudos!

I was looking forward to this book, but am returning it due to poor print quality. Many pages appear blurry because the font seems like it was subtly smeared during printing.

This book contains a solid amount of knowledge and ideas behind the functional approach.

The main drawback, however, is the programming language used: Clojure.

It is dynamically typed, with no types in function signatures.

This makes it rather difficult to follow long blocks of code—and believe me, there are long blocks of undocumented code in this book.

And yes, I believe Mark Seemann can follow it, as he wrote in his review. But no, I cannot.

I really wish Scala had been the language of choice instead; it is much more readable and statically typed. With type annotations, Scala code is much easier to follow.

Not to mention all the parentheses and prefix notation in Clojure. Being not an expert, what you mostly notice when looking at Clojure code are the parentheses, not the actual logic.

Thus, I give it a 3 out of 5. I highly appreciate the effort, but I believe there were better options available.

I'm a big fan of both Uncle Bob and functional programming. However, I found this to be the least approachable of any of his books. Why? Uncle Bob explains on page 259:

"I expect that as you read this book, you will have a good Clojure reference nearby"

That warning should have been on the cover. All of his functional programming examples are in Clojure. He does explain the basics of Clojure, and ramps it up with lots of footnotes. That was fine for the simple examples, but as the code became more involved, it was harder and harder to follow since my brain doesn't think in Clojure.

That being said, it is still a good book even if you start glossing over the code examples. Uncle Bob does a great job of contrasting FP and OOP. However, he goes from there back to showing how they are actually quite similar. He spends much of the book showing how the SOLID principles and a selection of design patterns are equally useful to either paradigm, just executed differently.

Uncle Bob also adds some much needed nuance to some of the oft sited advantages of functional programming. For example: "You can't have race conditions in functional programming." -> "Wrong. FP eliminates certain types of race conditions. Here is an example of a race condition in a functional program."

In the end, this book helped expand my ability to work within the strengths of both paradigms, and stop seeing them as mutually exclusive.

I am commenting on the terrible printing job the publisher has done. Pages are black speckled and not pure white. The paper is very thing and see-through so you can see the text/images printed on the reverse of a page. Reads more like a news-paper than a book. Pearson Addison-Wesley: shame on you! ...with my apologies to one of my favorite authors, uncle Robert C. Martin. (Pls send me a "real book" free of charge when you can.)

The book completely demystifies Functional Programming. Amazing explanation of SOLID principles with practical examples.

If you follow uncle Bob you'll know he's been threatening to write a book on Clojure for some time: this is it.

So if you're not after a book on how to write Clojure, this one's not likely to scratch your itch.

I'm still reading but, the name of the author says it all. Focus on what it really matters on a topics, or at least in my opinion, he has this skill to guide me connecting all the dots.