Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Steps in Scala : an introduction to object-functional programming
Loverdos C., Syropoulos A., Cambridge University Press, New York, NY, 2010. 504 pp. Type: Book (978-0-521747-58-5)
Date Reviewed: Nov 4 2011

In the early 1980s, many predicted that the next generation of programming languages would be declarative: either functional or logic. With Lisp, functional programming has a history stretching to the earliest days of programming. Logic programming had a boom and bust, while functional programming slowly converged on Haskell as a common standard. It became stuck, however, as a paradigm that theorists liked but few used in practice. Functional programming languished as commercial programmers found the abstractions of object-oriented programming better suited their needs. This resulted in a long period of time when it seemed as though the language wars were over, and Java had won.

Language wars have broken out again recently, with a rush of new languages claiming to be the next Java. Many of them are promoted as functional, or influenced by functional programming. Java, which seemed to have eclipsed functional programming, turned out to be its best friend. The Java Virtual Machine (JVM) proved to be an excellent platform for the quick implementation of new ideas in programming languages. A language that compiles into JVM code is not only runnable almost anywhere; it also has full access to the Java application programming interface (API), thus relieving the language designer of the task of implementing support aspects that are not core to the language, but are necessary in order to turn an idea for a language into a practical tool. Whereas Haskell was trapped in a closed, purely functional world that created a barrier against its adoption, the new JVM languages build on the idea of a lightweight scripting language, as pioneered by Perl with its slogan “There’s more than one way to do it.” The practical programmer can dip into using the neat abstractions of functional programming without committing to using it exclusively.

This book introduces programming in Scala, one of these new JVM languages. Anyone familiar with Java will immediately recognize Scala’s Java parentage. The book aims to teach programming in Scala from scratch, so many of its examples are purely object-oriented programming. The section that concentrates on the functional aspects of Scala is fairly brief, moving rapidly to some of the advanced abstractions that make functional programming attractive to some and impenetrable to others. Having taken the reader to this point, the book returns to cover Extensible Markup Language (XML) processing, graphical user interface (GUI) programming, concurrent programming with threads, and interaction with the Unix file system. This makes sense as coverage of the key aspects of a modern general-purpose programming system. However, because of this, the book’s target audience is unclear.

The book covers the topics in a way that assumes no previous experience, but anyone who really had no experience would find the coverage too brief to allow a good grasp of the topics. Having taught introductory and intermediate Java programming, I know that some of the topics covered in one or two paragraphs in this book actually require many hours of teaching and plenty of examples before even the most able student properly grasps them. This applies in particular to the more abstract aspects of object-oriented and functional programming. I feel that a book that really is oriented toward the novice programmer needs to spend more time on this.

On the other hand, someone who is already familiar with XML and GUI programming, and the other practical topics, would probably prefer a text that builds on the assumption that the reader already knows the basics. I would have liked to see more on how the functional aspects of Scala interact with aspects of programming generally introduced in a heavily imperative way. The book gives plenty of detail on incidental aspects of the Scala language, but covers the language in a somewhat random fashion; in several places, the authors throw in key points as asides because they need to illustrate something else. For this reason, and because often the details are not given in a comprehensive way, the book would not serve as a good reference work on Scala.

My impression is that the authors have tried to cram a lot into one book, but wanted to avoid a 1,000-plus-page textbook. I appreciate that, because such textbooks often drown the important with the incidental. At around 500 pages, this book is a nice size for getting a taste of Scala. However, I would prefer a book with more of the basic principles and patterns of programming in the language, and only summary coverage of what else is needed to link the language to the real world. It was good to be convinced by the book that Scala is practical for real-world tasks, but I don’t like to be thrown into such details before I properly understand the core of the language.

Reviewer:  M. Huntbach Review #: CR139560 (1204-0331)
Bookmark and Share
 
Object-Oriented Languages (D.3.2 ... )
 
 
Applicative (Functional) Programming (D.1.1 )
 
 
Object-Oriented Programming (D.1.5 )
 
Would you recommend this review?
yes
no
Other reviews under "Object-Oriented Languages": Date
Understanding object-oriented: a unifying paradigm
Korson T., McGregor J. (ed) Communications of the ACM 33(9): 40-60, 1990. Type: Article
May 1 1991
From Fortran and Algol to object-oriented languages
Wilkes M. Communications of the ACM 36(7): 21-23, 1993. Type: Article
Nov 1 1994
Object-oriented programming with prototypes
Blaschek G., Springer-Verlag New York, Inc., New York, NY, 1994. Type: Book (9780387564692)
Feb 1 1995
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy