This book teaches imperative and functional programmers how to write programs that are more than the sum of their parts. It shows how to write programs that are fault-tolerant and scalable by using functional abstractions, type classes, modules, and other patterns. You also learn how to avoid the common mistakes made by new and inexperienced functional programmers. The book also gives you the opportunity to practice your skills with real-world problems and see how well you perform under stress.
While the book covers a lot of ground, it is not too heavy on the reader. I found myself reading and rereading portions of the book multiple times to get all the information across. That being said, I would still recommend this book for people who are just starting out with imperative programming, but who have an interest in functional programming as well.
This is also a great book for people who are interested in functional programmers but don’t know where to start. This book gives you a good place to start so that you can build up your knowledge on the subject. It is an easy read and offers excellent information.
Overall, the book covers a lot of ground but doesn’t overwhelm you. In fact, it is a very well-organized text, which is a plus because some sections are better than others. I liked the sections on type classes and fault-tolerance, as I am a fairly conservative kind of person.
One thing I did not like was that there were some sections where there were sections left out that I would have liked to have seen included in the book. As for the writing style, I found the style to be somewhat repetitious and some portions to be confusing at times. I also felt the flow of the text was slow, especially towards the end.
Overall, the book reviews online were favorable and the book itself is well written. I am pretty sure that I will still enjoy learning Erlang/Elixir because of it’s simplicity and clarity. I would recommend this book to anyone that wants to learn functional programming.
There are many books available on the market today that cover similar topics, and this book is not any different. However, the reason why I like it more than most is that this book is written by a true professional, who has been an imperative programmer for many years. This gives me the added confidence and understanding that someone who has been working in imperative programming for years can still write about it in such a manner that I will be able to understand it.
I also liked the writing style because it gives you a general introduction to functional programming. and then goes into more detailed information on the subject matter. The book makes it easy to understand the theory of imperative programming, and then goes into detailed examples that illustrate certain concepts.
Functional programming is a broad subject that cover a number of subjects, including distributed computing, concurrency, modular programming, distributed processing, and concurrency control, but the author does a good job of explaining those topics. He also covers how the concepts are related to each other in a way that is easy to understand. For instance, distributed computing is a good example of a concept that relates to functional programming, where we say things like “the network behaves like a database.” The concepts are easy to understand and relate.
I found the book to be well-organized, and the information it provides is easy to read and comprehend. I really enjoyed reading this book.