Joshua D. Suereth

The first read of this was largely in its pre-release state. I'm currently on my seconding reading.

Overall I came away feeling strongly that this was the best book to read after you've had some exposure to Scala and want to go a bit deeper (ok, perhaps a LOT deeper, in some areas). Josh clearly knows his stuff and is enthusiastic to share it. He covers a broad-range of Scala's more complex features, but makes them approachable and understandable. I suspect this will be a book I'll be referencing time and time again.

There are some weaknesses in the book. A few areas I, in particular, I felt could have used a bit more clarity. But my biggest gripe is just the poor editing -- there are a lot of typos and in some cases these are in the code examples. This unfortunately can make it harder to understand what's being explained.… (mehr)

First, the good parts: The book delves into very important and advanced Scala programming concepts and techniques such as type classes, advanced use of implicits with the type system in order to create compact and flexible coding designs, combining object oriented programming techniques with functional programming, pitfalls of integrating Java with Scala and workarounds to deal with them, and parallel and asynchronous programming techniques with actors. It ends with a very brief introduction to advanced functional programming techniques that rely on the solid foundations of category theory.

This is a very didactic and highly opinionated book, laying out the best practices and rules to follow, along with pitfalls to avoid. Suereth tries to motivate the reader with concrete, real-world examples in order to help better understanding, even when the subject matter is relatively abstract and advanced.

The bad parts: It really feels like it has been rushed into production. My concern is not only spelling and grammar mistakes, much more important than them are some strange repetitions as well as lack of explanations at some places in the book. I have a hard time believing that the final manuscript underwent a serious editorial effort. I know that Suereth is a very experienced Scala developer who contributes enormously to many Scala projects, but apparently writing a good technical book, taking into account the pedagogy of the reader, especially when it comes to explaining very advanced and abstract programming concepts and techniques, is a very difficult task. It is like some parts of the book have been written with a very focused mind, aiming to be crystal clear, whereas some parts feel like the author dragged himself to finish the chapter. Dropping a few links here and there for further reading, and referring to the online code for better understanding is not always very helpful either.

The verdict: If you have learned the basics of Scala and want to move to the next level, then this book can be very helpful. Another important fact is that there is no competition yet, the book is the only one in its category. In other words, until a better book is written covering same topics, you either need to learn them by yourself or read this book for a concise and concrete introduction.… (mehr)