Author: Joshua D. Suereth
Audience: Existing Scala programmers
Reviewer: Alex Armstrong
Scala is a hot language, especially for Java programmers. Is an in depth view exactly what you need?
The problem with Scala is that it is different. This of course is also its attraction. It runs on the JVM and can work happily with Java and other JVM languages. This makes it interesting to any existing Java project or programmer wanting to inject some new ways of doing things. However, Scala is an object-oriented functional language, and while the object-oriented part might be familiar functional programming is not the mind set of the average programmer.
This particular book is a sort of introduction to Scala, but it really is only suitable for a programmer who already knows the language. In fact the more Scala you know, the more you will get from this book.
How can a book be an introduction and yet demand that you already know the language? Because when it comes to Scala, and other functional languages, it is quite possible to learn the language without really understanding what it is all about. You can treat Scala in a way that is more like Java than Scala.
What this book sets out to do is educate you in the ways of thinking of a functional programmer and a Scala functional programmer in particular.
It starts off with a chapter that sings the praises of Scala, which is fine if you know a little about the language. Before the book even gets into any details of the language, it is explaining how it interacts with the JVM. If you have never really understood functional programming this chapter does a good job of trying to convert you.
Chapter 2 is called "The Core Rules" and it explains how you should use Scala and draws attention to the sort of things that Java programmer continue to do and so misuse Scala. Next we have coding conventions which are actually more important than you might imagine. Chapter 4 focuses on object orientation in Scala.. Chapter 5 deals with implicits, 6 goes on to the type system and 7 covers the way you should use implicits and types together.
Chapter 8 is all about using collections - mutable and immutable. Chapter 9 deals with actors - Scala's way of dealing with asynchronous tasks.
The final two chapters round off the book with a look at mixing Java and Scala and some more advanced theoretical topics. If you have heard the term "monad" and wondered what "category theory" was all about, this is the place to find out. However, it is worth pointing out the book is not overly theoretical, even in this final chapter. Overall, the style is easy to read and the light conversational style works well.
This is a good book - perhaps even an excellent book - but only if you are the right reader. I can imagine a Java programmer picking this book up, because it does say
"Written for readers who know Java, or another OO language"
and finding the content very difficult to follow. My advice is at least to find a little out about coding in Scala before trying to read this book. The ideal would be if you were able to write a program in Scala, but were not entirely clear as to why you were doing things in a particular way.
If you fit this profile then this book is highly recommended.