The author has written a rich and thorough text that delves deeply into abstract issues. His work introduces inheritance as a completely new paradigm compared to what is generally understood by practitioners. The book covers all aspects of the topic, and revisits concepts many times over to make sure that they are driven home.

Being a dissertation artifact, this book is inevitably oriented towards research. The presentation style strongly reflects its academic nature. The book’s title mentions “software construction,” but the subject matter is more precisely focused on design. Nonetheless, the book does give an insight into what inheritance should be used for, although the reader will have a long way to go before the concepts mentioned in this book can be implemented in real design and development.

The book starts with a detailed explanation of inheritance, and the nuisances associated with it. Chapter 2, “Current Understanding of Inheritance,” lists out all the conceptual issues associated with inheritance very well. It clearly differentiates between subtyping, subclassing, and Is-a relationships, and provides a good understanding of inheritance as a concept. It also sets off a clear path for subsequent chapters. However, the structure of chapter 2 could have been improved. It should first have introduced the concepts, and then introduced their impact on the use of inheritance. The sections “What Is Inheritance” and “Understanding Inheritance” could also have been merged into one to avoid repetition.

Since the subject of this book is very abstract and involved, it would have been easier on the reader if the text had been simplified a little. Some overcomplicated statements could have been written in much simpler form and conveyed the same meaning much more effectively. For example, I needed to reread a sentence on page 30 (“Passing an object held in a supertype variable into a method may have a different result to passing in the same object held in a subtype variable”) several times over. I have still not been able to grasp its meaning!

In chapter 3, “Structured Inheritance Relationships (SIRs),” the author introduces the five SIRs: view, variant, construction, specialization, and evolution. Although the concepts are explained fairly well, the lack of examples and diagrams is acutely felt here, as it is elsewhere in the book. Some very simple concepts have been explained with complicated and sometimes confusing sentences. For example, the glossary in Appendix A defines subtype as “the more general type in a subtyping relationship” and supertype as “the more specific type in a subtyping relationship.”

In chapter 4, “A New Model of Inheritance,” the author introduces ways in which SIRs can be modeled. The differentiation between primary and secondary types is interesting, as is the examination of the abstract superclass rule.

Chapter 5, “Techniques for Structured Use of Inheritance,” finally talks in practical terms, explaining how SIRs can be put to use. Four architectural qualities (variability, modifiability, extensibility, and reusability) are used as guiding parameters in explaining the various techniques to achieve these qualities. It is in this chapter that most of the pieces start to fall in place.

The same approach has been taken in chapter 6, which discusses some interesting case studies. Two problems of modeling, “restricted subclasses: square/rectangle problem,” and “binary methods: point and colored points problem,” are discussed. Various models, such as the time efficiency model, the space efficiency model, the restricted views model, the full substitutability model, and the reuse model, are used to show different perspectives on solving these problems.

In chapter 7, the author discusses implementation techniques with respect to object-oriented languages, mainly C++ and Java. The reader may wish that the examples given here had been mentioned in the first few chapters as well: it would have made for much easier and more interesting reading.

Being a dissertation-level work, this book requires a good background in object-oriented philosophy, and an in-depth knowledge of at least one object-oriented language, preferably C++ or Java. The book also needs to be read more than once in order for its essence to be clearly comprehensible.

This is a complete book that explains inheritance in great depth, but it needs serious editing to remove its many typographical errors and impenetrable sentences. Barring these shortfalls, I recommend the book to researchers and practitioners who want both to understand inheritance, and to apply it in the best possible manner for maximum benefits.