Scala in Depth [Paperback]

I am experienced Java programmer, so "Scala in Depth" offered me what I was looking for - a jump straight into the language, its
syntax specifics and idioms without teaching me what is loop, if-else or object-oriented programming.

Book is written for someone who knows how to program, who is motivated to learn a bit different language than Java and who is willing to appreciate
two key aspects of Scala - conciseness and functional programming orientation (in addition to its OO nature).

Readers should pay attention to the orientation of the book. If you are a person willing to learn new language and you did not write much of a Java or C# code before you might be better of starting off with some other books (there are many great ones).

If you are experienced programmer and you want to see what is the big deal about Scala then this book will offer you chapters on what does it mean to write effective Scala programs, understanding of the actors and how to effectively apply them, monads, effective functional programming.

As a final note, I give it five stars because I think that it was witten by a person who is a strong programmer and who knows how to effectively communicate the key points of this language.

Very good book, the name is right it does go into depth. I would probably not recommend this book as your first Scala book, for that I would go with "Programming in Scala". But after that and after you get started this would be a great book to read next. I really goes into some useful deep stuff.

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 on-line 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.