ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Search in Book Reviews

The ACCU passes on review copies of computer books to its members for them to review. The result is a large, high quality collection of book reviews by programmers, for programmers. Currently there are 1918 reviews in the database and more every month.
Search is a simple string search in either book title or book author. The full text search is a search of the text of the review.
    View all alphabetically
Title:
Foundations of Object-Oriented Languages
Author:
Kim Bruce
ISBN:
0 262 02523 X
Publisher:
MIT Press
Pages:
383pp
Price:
£30-95
Reviewer:
Francis Glassborow
Subject:
object oriented
Appeared in:
14-4
Do you want to understand the foundations on which object-oriented languages such C++ and Java are built? Do you want to be able to criticize design decisions that were made in developing an object-oriented language? Do you want to develop and defend proposals for change or extension to an object-oriented language? If the answer to any of these questions is 'yes' then I think you need to understand the material that is presented in this book.

This is not a book addressed directly at the practitioner though understanding the under-pinning of the languages you use may well help you to use them more effectively. For example, a clear understanding of the distinction between subclassing and subtyping together with the problems each seeks to solve will inevitably improve your design of class hierarchies.

Now one interesting feature is that the author's claimed objective is to deal with statically typed class-based object-oriented programming languages. However I feel bound to question the use of 'statically typed' in that sentence because, as I understand it, any object-oriented language must support a degree of dynamic typing to give runtime polymorphism. However I think he mainly wishes to exclude languages such as Smalltalk that are exclusively dynamically typed while including languages such as Java that allow static typing, (though not by default for user defined types). I have to admit that I struggle a little with the author's view of Java. I see its default type system as far closer to Smalltalk than to C++. It is true that Java variables are statically typed, but so are C++ pointers and references. However the underlying object (that bound to the variable in Java or reference in C++ or pointed to by a C++ pointer) has a strong dynamic element to its type. But we should note that the fact that I can enunciate points of disagreement is actually a positive aspect of the book. It makes me think and question and thereby deepen my understanding.

The book is divided into four sections. In the first section there are seven chapters that cover the fundamentals such type systems, classes, subtypes, subclasses. It concludes with a chapter describing the basics of multi-method, object-based (not exactly how I have understood the term in the past) and class based languages. Reading that made me think again about the frequent suggestion that C++ should be extended to include multi-methods. As far as this author is concerned those belong to a quite different form of object-oriented language.

The second section consists of two chapters giving an essential introduction to the lambda calculus. The advantage is that this presentation is focused on its use to model object-oriented languages. Nonetheless it is demanding and many will find the formalized expressions quite daunting.

The third section, titled 'Formal Descriptions of Object-Oriented Languages'. In fact the author develops a simple object-oriented language (SOOL) as a mechanism for communicating these ideas.

The final section consists of four chapters considering various ways of extending the language of the third section. Here we will learn about such things as bounded polymorphism, the concept of self (called MyType in this context), match-bounded polymorphism before concluding with consideration of dropping subtyping and substituting matching and hash types.

The book, overall, makes interesting reading whilst leaving me with a distinct sense that commercial interests and the requirements for backward compatibility make the application of the many lessons to real languages hard if not actually impossible. Many of us recognize that within C++ there is a simpler and yet more powerful language trying to escape and this book only serves to confirm that feeling. A good book for language lawyers and others interested in language design.