To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyses reviews to verify trustworthiness.
Solid and detailed book on Scala. Written in a practical manner - very focussed on introducing functional programming concepts through Scala. Offers a good knowledge bridge for OOP programmers wanting to move into incorporating more functional programming techniques.
First let me say that scala is a very tough language to learn, it has a lot of tough semantics in it. However, if you learn it, you could dish out code faster than any java 8 developer. I'm going to try very hard to not make this a review of scala the language. Even though I like scala in general, I could easily write several pages of criticism for the language.
In general, this book is great and very thorough. The authors went into a lot of detail on many topics. I would highly recommend this book to anybody. However, I'm partly saying that because the scala-lang website documentation is old, insufficient, and completely out of order.
That being said, there are some parts that are far more confusing than they need to be. The author has a bad habit of showing you a feature in scala long before he explains it, and that is why I decided to give this four stars instead of five.
Chapters four (pattern matching) and five (implicits) were especially difficult to follow because the authors kept using language features before they explained them. I had to read each of those chapters twice before I understood them. - They show you implicit type conversions a whole ten pages before they explain them (shown on page 139, explained on page 149). So of course I spent a half hour trying to understand the example before giving up. - They start using '+:', ':+', and '::' in chapter four before they explain them. - They use infix notation for types long before explaining it. - Their explanation of "<:<" and "implicitly" still confuses me now, after reading that section several times.
Another thing that really bugs me is the obvious bias that the authors have for functional programming, ignoring some major flaws it has that any java veteran would see.
However, I should base my rating on how well you could learn scala the language from this book. Like I said, it goes into pretty deep details on most topics, so you could become a scala master from this book.
This will probably come across as a harsh review of the book but I want the potential buyers to know what they're getting into when they buy this book. Just to put into context of where I was when I purchased this book: I consider myself a seasoned software developer; I've adapted a functional way of doing Java development since the introduction of Google Guava pre-v8 and adapted the native lambdas and streams as soon as Java 8 became ready for prime time. I have also written software using Groovy but not as large scale.
Now on to the review of this book. As other not-so-positive reviews has mentioned: this book goes to the deep end way too quickly, introducing advanced concepts without much explanation and by the time it finally (tries) to connect the dots, the reader is already drowned in confusion and frustration. Just an example, it introduces Akka actors in the beginning chapters. Yes, I know! The very essence of Erlang thrown right on your face when you barely went through the book's "hello, world" example! It kind of feels like Tom Cruise's character in "Edge of Tomorrow" on his first day on the battle; you're sent to kill these horrific-looking Cthulhus when you can't even disengage your weapons safety switch.
Scala is a *difficult* language as it is already, with all of its nuances and enough syntactic sugar to cause diabetes, and this book does not help so much in getting the reader learn at a good pace. I literally found myself reading sections more than twice trying to decipher what I've just read. I felt dumber every time I put the book down to resurface.
The authors are clearly smart and are Scala experts. I think this book's failure is mainly due to terrible editing/organization and not establishing who really its intended audience is: is it a Scala beginner's book or a Java-developer-transitioning-from-imperative-to-functional-book? I believe it would have been more successful if it focused on the latter.
This an awesome book that teaches Scala from 0 to a 100. I am enjoying reading through the book and learning the Scala language. It's also worth mentioning that the authors put in considerable amount of work, with code examples that you can down load from github. However, this book comes short of one star for me because I think that it spends unnecessary effort bashing the java language. it just comes off as though the authors had negative thoughts about Java, because most of the discussion concerning Java vs Scala and how/why Scala is better that java, and why you should use Scala instead of Java just seems so irrelevant to the topic of learning Scala. Like the fact that someone is reading this book already says a lot about them trying to learn Scala. I am only reading the book to completion and putting up with this negative criticism of one of the world's powerful languages (Java) because I have to learn Scala for my job.
And to the authors, if you decide on making a third edition, please consider focusing on Scala and highlighting it's positives without leaning on what you consider to be the flaws of Java. If Scala is truly better than Java, it will speak for it self. And to say the least, the fact that Scala builds so much on Java only speaks to the power of the Java Programming language.
This book was not the first Scala book that I read. I read Cay Horstmann's book Scala for the Impatient and partially read Odersky's book. The Horstmann book is itself a very good book. So I thought that reading this book would just be "review". Instead, I found this book treating topics in a much deeper way than I expected and that it really broadened my understanding and horizons. I can tell that a lot of work went into this book and its organization. I found it well worth the read and $.