Not surprisingly, this book is about software components. Therefore, you might expect this review to begin with a definition of that term. Unfortunately, that’s no easy task. In fact, the authors struggle with it for almost half the book, and chapter 11 presents alternative definitions from 14 different authorities. In the end, the authors resort to a definition that is different from the one they used in the first edition of the book. Suffice it to say that, for our purposes here, a component is a unit of deployment, a “chunk” of pre-built software that can be cobbled together with pre-built components to assemble systems. This contrasts with the classic approach of building systems from scratch by writing most of the software for them. Although our loose definition of component could perhaps be applied to the definition of objects in the object paradigm, or to subroutines in the procedural paradigm, the implication is that a component is a somewhat bigger chunk of software. The book makes other distinctions as well.

The reader may object to this definition, in that assembling systems rather than building them from scratch is what was envisioned for object-oriented technology. That object-oriented technology will never result in the widespread use of catalogs of pre-built software objects is becoming increasingly apparent. The book discusses why, along with the reasons why software components hold out the promise of achieving this aim. Whether software component technology ever fulfills this promise, or simply joins a long list of good technologies (GOTO-less programming, structured programming, structured design, object-oriented paradigm, client/server, and so on) that failed to achieve all their hype remains to be seen.

Currently, component software technology originates from three camps, each with its own distinct approach: Microsoft’s .NET, Sun Microsystem’s Java, and the Object Management Group’s standards.

The book contains a wealth of information about component software, including both technical aspects, and non-technical aspects such as business models. A wide range of approaches is used, from technology comparison, to computer science theory, to philosophic essays. A fairly advanced reader is assumed throughout. Unfortunately, most of this potentially valuable material is presented in such an abstract way that is difficult to understand. Limited use is made of examples, and the few that are presented fail to clarify the material. As a result, the reader struggles to relate the wealth of information to something concrete. Many sentences are loaded with multiple high tech terms, further compounding the reader’s difficulty.

One also has to question the choice of material that is presented. Consider, for instance, the book’s introduction to Extensible Markup Language (XML). One might expect this discussion to begin by addressing the most important XML features, such as tags and attributes, illustrated with a simple XML example. No such example appears. Instead, the material begins with a description of the role of the ampersand character, and the escape sequence for it (hardly a key topic). Consider the introductory material on the Java language. In Java, packages have a relatively minor role, and would not necessarily even have to be covered in a few page introduction to the language. But, in this book, the introduction to Java begins with an in-depth critique of minutia regarding the syntax used to denote packages. Why? As a result, unless the reader is already knowledgeable about the subject, they are left with a myriad of details, with no clarity as to what is important and what isn’t. The book is even physically difficult to read: narrow margins cause the words to curve in towards the spine.

This book may provide some interesting insights for readers who are already heavily involved with software components, affording them the opportunity to view the topic from new perspectives. The material that dissects inheritance, and shows how this term really applies to a range of concepts, is particularly enlightening. Most readers, however, will find the myriad of details to be more confusing than enlightening. For them, the book fails to shed light on the important and timely topic of software components.