Scala is a very interesting modern programming language. Designed in 2001 and still evolving--slowly, but still evolving--Scala is a statically typed language designed to support functional and object-oriented programming, to operate seamlessly with Java, and to run on the Java Virtual Machine (JVM). A version for Microsoft’s .NET Framework--more precisely, a version that would generate bytecode for the common language runtime (CLR) environment--seems to have been recently completed; the official Scala language Web site [1] states that it is available.

Scala is a powerful, complex language with a lean and flexible syntax that puts the burden on the programmer to understand how the very active and intelligent compiler will interpret his code. The programmer has choices: he or she can write very conservatively and somewhat verbosely, very concisely, or somewhere in between. Reading Scala, though, can be easy on the eyes and comprehension is usually quick, assuming that the reader is acquainted with a rather broad range of conceptual approaches to programming and knows several programming languages very well. This points out that Scala is not an easy language to learn, let alone master. In fact, the language’s Web site recommends that you learn Java before attempting to program in Scala. The authors identify their intended audience as follows:

If you are an experienced developer who wants a fast, thorough introduction to Scala, this book is for you. [...] We assume that you are well versed in object-oriented programming, but we don’t assume that you have prior exposure to functional programming. We assume that you are experienced in one or more other programming languages.

Throughout the text, Wampler and Payne often point out similarities and differences between Scala and other programming languages, mostly Java and C#, but also a few others. In fact, this often distracts the readers from their understandable quest to focus on what is, for them, a new programming language.

Considering the scope of the subject, this is a fairly short book. The book contains a foreword, a preface, 14 chapters, two appendices (a list of references and a glossary), and an index. As Wampler and Payne warn, their presentation is thorough, but often fast. The readers would be better prepared if they had a thorough conceptual understanding of various concepts related to programming theory and approaches, and deep acquaintance with a variety of programming languages. As the content of the book is available online, I will abstain from giving an overview of the contents; rather, I will concentrate on the strengths and weaknesses of the book.

The book is strong in several areas. It provides a thorough introduction to Scala at a level the experienced programmer will understand and appreciate (the inexperienced programmer may find it limited or confusing). Coding samples are clear, well thought out, relevant to the topic, focused, and short. Wampler and Payne make every effort to use good Scala coding practices, and provide a reason if they sometimes deviate from this approach. Explanations are good, clear, and concise, but sometimes I was surprised at what was left out. The bibliography is excellent--current and extensive. Appropriate references are mentioned throughout the text. The glossary and the index are both excellent--I could only think of a couple of entries missing from one or the other, but I had no trouble looking them up (although I could not find one in the book after searching rather diligently). The authors are clearly intimately familiar with Scala and enthusiastic about it. Throughout the text, they point out appropriate changes or improvements in the upcoming 2.8 version of the language.

Unfortunately, the book suffers from two flaws. I have already alluded to one of them: Wampler and Payne’s tendency to go overboard in comparing Scala to other languages. They also bring up tangential theoretical or conceptual discussions more than occasionally; thankfully, these are usually brief. While they may be interesting, I found them distracting in my effort to learn and understand Scala. I would have preferred a sharper, more exclusive focus on Scala, perhaps including no more than a handful of references to other languages, when absolutely essential.

More egregiously, the authors use a superabundance of quotation marks--mostly incorrectly--that are hard to ignore. I found them distracting rather than helpful.

Nevertheless, an experienced programmer can learn a great deal of Scala from this book. Clearly, this book is meant and best used for self-study, but it could also be used as a textbook at the upper undergraduate or graduate level.