If anyone needs to be reminded of how much the information technology (IT) field is driven by hype and fashion, one only has to look at the successive waves of programming languages. In a single generation, we went from procedural programming to object orientation (OO), and now functional programming (FP) is making a comeback.

This comeback is driven by the difficulty of writing correct object-oriented programs for concurrent systems, and it is supported by the assumption that immutable structures, such as those employed in FP, are better suited for solving parallel programming problems. At the same time, years of evolution have endowed existing languages with a wealth of libraries, and efficient compilers and runtimes; it makes little sense to discard them all.

Scala attempts to combine OO and FP by bringing FP concepts to a language derived from Java (although, apart from the standard compilation to Java Virtual Machine (JVM) bytecode, it is also available for .NET). Scala’s OO constructs will look familiar to Java developers; indeed, Scala looks like an updated version of that language. If Java were designed today, it would probably be Scala. Scala’s FP constructs will also look familiar to most developers. Its support for concurrency via the Scala actors library--a concept borrowed from Erlang--and its compatibility with Java’s huge library corpus makes for a compelling combination.

However, this is not a review of the language, but a review of a book about the language. Inexperienced with Scala, I approached the book with the expectation that it would bring me up to speed with the language and allow me to start programming with it. It did not turn out this way.

To be sure, Scala is not an easy language to learn. Its syntax allows programmers to write elegant programs with a minimum amount of code, though sometimes at the cost of readability--code fragments may look like Perl. Combining OO and FP, and maintaining compatibility with Java, makes this a large language; while it is not as large as C++, it sometimes gives off the same baroque feeling. This book offers a wealth of information on Scala’s sharp turns. It provides code fragments that will make language lawyers salivate. It also gives plenty of examples of the language, especially with libraries that facilitate behavior-driven development.

That being said, it neither provides an in-depth discussion of the language’s essentials nor an explanation of the language’s design choices. Considering the reader is swiftly taken from writing toy problems to more extensive programs, it is easy to get lost--the many cross-references aren’t much help. For example, one chapter covers domain-specific languages (DSLs) and Scala. While the ease with which programmers can develop DSLs using Scala is one of the language’s selling points, this chapter, like many others in the book, is not written for newcomers to Scala. Of course, seasoned Scala programmers will presumably get much more out of it.

Therefore, it may be telling that, after a couple of days with this book, I started reading it in tandem with Programming in Scala [1], by Martin Odersky (the creator of the language), Lex Spoon, and Bill Venners, which is arguably the standard book on the language. Reading these books together helped me to better understand traits and the Scala object model. Interestingly, on the back cover of Wampler and Payne’s book, Venners rightly endorses Programming Scala as a complementary book to his own.