Spreadsheets have been a main staple of modern computing since the early 1960s, although they have not gone through much significant change or evolution in the last decades. A particularly interesting aspect of this is that spreadsheets are an example of functional programming, which is now in favor in almost all current programming languages for multiple reasons, but largely for its potential for parallelization due to the underlying graph model of evaluation.

However, current spreadsheets have numerous weaknesses as a programming system or development environment, notably a lack of common semantics of a programing language and easy extensibility in a current language. Sestoft’s book starts with a nice summary of these issues and how one reason for the lack of experimentation and innovation in this area may be that there is no open-source platform for such development--his system and this documenting book aim to remedy that.

Sestoft describes a core implementation, called CoreCalc, and then based on that a more advanced version, called FunCalc, which extends CoreCalc with several features, most notably user-defined functions. In general, the book is an extended tutorial and documentation for the software project, and the decisions and designs underlying it, rather than a tutorial or more abstract discussion of the overall topic. A majority of the chapters provide a detailed review of the underlying code and implementation. The result is an interesting experimental system, but it is quickly clear that FunCalc is not a production-level tool, and one will quickly find that it is missing much of the visual graphical user interface (GUI) manipulations that are so common and familiar in Microsoft Excel.

The language choice for such a system presents an interesting tradeoff: the semantics and models of a spreadsheet are not easily embedded in a typical standard language, yet creating a new unique language immediately isolates it from reuse and requires an additional learning curve for adoption. Sestoft chooses the latter and defines his own new language. There are big gaps between the implementation language of his system (C#), the parallels to a functional language model, and his user-defined language that seems more akin to a new Visual Basic for Applications (VBA) dialect (I would have preferred some variant of a subset of a functional or more familiar language). Nonetheless, the author makes a case for his choices and provides much detail on the implementation. I suppose one response might be that here is a working implementation on which to build any such language one might wish; after all, that is the intent of the book.

The focus on issues affecting system performance in the implementation of FunCalc adds another useful dimension to the project and the descriptions in the book.

This book is interesting and useful in several areas, including as a case study of a large project, yet is also accessible as a basis for projects in an academic course, integrating languages, compilers, software design, and other interrelated areas of implementation. I especially like Sestoft’s usage and description of functional programming features in his system, including the graph model of calculation, the resultant lazy evaluation, and non-strict functions.

A strong point of the book is that it gives a good description and tutorial on all of the underlying concepts and techniques in the accompanying project, again making it more useful for either self-learning or the classroom. Sestoft’s strong research and academic background show through, making this book very useful for both arenas.