|Adam Petersen - Software Development Pages, Book Reviews Section|
Patterns of Software: Tales from
the Software Community
"Patterns of Software" is not a pattern catalogue a la “Design Patterns” – Richard P. Gabriel’s book is more on the philosophical plane than on a technical one. The book consists of a collection of essays covering a broad spectrum of topics.
The first part, also named “Patterns of Software”, relates software development to the work of Christopher Alexander. The ideas and work of Alexander, an architect of the kind that builds real buildings and bridges, has had a tremendous impact on the software world as the main influence to the early pattern movement in software. In this part, my personal favorite is “Reuse versus Compression”. This essay explains why inheritance does not equal reuse. I really do wish I could say this topic is old news by now, but I still believe many OO designs suffer from erroneous use of implementation inheritance. To make it more interesting, Gabriel’s essay is written in a time where object-orientation had just entered the mainstream and inheritance was the latest silver bullet. The basic idea captured in the essay is that inheritance implies compression in the sense that the meaning of a certain part is larger than that of the part itself. That is, when using inheritance, a class draws part of its meaning from the surrounding context, which means from the class it inherits from. Besides the technical issues (inheritance is the strongest type of coupling between classes), the people-oriented disadvantages are obvious: not only does a programmer needs to understand the context from which the compressed code takes its meaning; Gabriel points out that due to the complexity of compressed code, it “will take at least as much time and effort to write as it would to write the uncompressed code”.
The second part of the book discusses programming languages. Here I liked the essay “Language Size”, which basically discusses the merits of a small language versus a language with a large library. The main examples are drawn from the Lisp world: Common Lisp with its small core but large library and Scheme which is considered a small, elegant language. Another highly interesting piece is the theatrically sounding “The End of History and the Last Programming Language” where Gabriel outlines his theory on what makes a language successful. The base of his theory is that languages get successful by a social process, not a technical one: the most important factor is not the nature of the language, but the human nature.
The rest of the book contains “What we do” (here the “we” refers to computer scientists and OO designers) where the intent is to reflect about how the outside world views “us”, Gabriel’s autobiography (title “Life of the critic”) and finally the story about the rise and fall of his start-up, Lucid. The latter makes the interesting point, learned over and over again, that the products may be technically superior and yet the business may fail when humanity is forgotten. The final essay “Money Through Innovation Reconsidered” brings it all together as Gabriel connects to his classic paper “Worse is better”. Basically, he is stating that the market does not necessarily reward the best product and that the mainstream customer doesn’t want to take risks. This means, no revolutionary changes, but rather small incremental improvements.
With such a diversity of subjects, it is unavoidable that the different parts will attract different readers. For me, the latter parts of the book fall in the less interesting category, but please note that this is a pure matter of personal taste and interest; all essays are superbly written and almost all of them contain interesting observations well worth reading for an experienced software developer.
Reviewed November 2006
|©2005 Adam Petersenemail@example.com|