Customer Reviews

Design Patterns and Contracts

5 star:		(1)
4 star:		(1)
3 star:		(1)
2 star:		(2)
1 star:		(0)

 

 

If you have already read the famous 1995 book, Design Patterns, by Gamma, Helm, Johnson, and Vlissides, you will enjoy this excellent sequel tremendously. It brings into sharp focus each of the object-oriented design patterns listed in the 1995 book by giving even more clear and more readable examples. It also adds the vital element of software contract: preconditions which must be met by a client before calling a routine, and postconditions which are guaranteed to be true after a routine completes its work.

If you have not read the 1995 book, don't bother. Buy this one instead. You don't need to have read Design Patterns to get full value out of this newer book.

The book uses the Eiffel programming language for its examples mainly because Eiffel does such a good job supporting contracts. Prospective readers who have closed their minds to anything not centered around Java or C++ will miss a treat if they pass up this book. Eiffel is written using English words. You don't need a language reference manual to read the Eiffel examples. The authors of this book have guided the reader through the Eiffel examples painlessly and do not require any prior contact with the language.

If you do buy a copy of this book, don't miss reading the case study in Chapter 6 on software configuration management. The general concept presented here is extremely valuable to any software developer. The authors kill two birds with one stone: design patterns are illustrated and a very eligant simplification of the software configuration management problem is proposed.

I highly recommend this extremely practical book.

If you want to learn about design patterns - don't buy this book! The most of the book is in Eiphel language which is not so easy do understand. To understand the design patterns with the examples of the book is very difficult. I bought this book because of it stars - but it was my big mistake!

After reading Jean-Marc Jezequel's excellent first Eiffel book, I was looking for more information on "Design By Contract", and its impacts on real-world projects. Based on the author and subject matter, I immediately ordered "Design Patterns and Contracts."

I was somewhat disappointed with the first section, covering the basics of UML, Design Patterns, and Design by Contract. There are many other references that do a better job of covering these basics. It also had the bland feel of an "Executive Summary" chapter, complete with an overabundance of whitespace, diagrams of questionable value, and concept definitions that would probably have been better off in a glossary.

Things rapidly improve after the first short section. The second part of the book is an excellent resource for the most common design patterns. This section makes a great reference, and I find myself refering to it from time to time for guidance, even when not using Eiffel.

I also greatly enjoyed the third part of this book, which brought the whole discussion into concrete terms by describing several case studies based on the authors' works. This section was very helpful in seeing the design patterns in action.

The one missing piece that would have forced me to give a 5-star rating would have been more discussion of how Design by Contract had a measurable impact on their work. For example, did the use of pre- and post-conditions allow them to find any esoteric bugs that might have gone unnoticed in another implementation language? Did they find that their software was measurably more reliable then systems built using other languages? But these are minor complaints, and can be satisfied through a literature review. This book is an excellent companion volume to your other software design volumes, and is a bargain at its retail price.

This book is very very very hard to read. The language is extremely cryptic. The words used are so hard that one has to keep an english dictionary handy. In order to lookup a word in the dictionary and then try to understand the whole sentence within the context is really hard. It really easy to loose track of what is it that I was trying to understand in the very first place.

I gave it 3 *s because of the practical approach the book has taken and I dont mind the use of Eiffel as the language of choice for writing the code since it could be a worthwhile excercise to actually develop the full SCM software in Java/C++ or other languages.

The chapter 6 and chapter 7 are really so good that it can be worthwhile going through the painful exercise of looking up every 3rd word from a dictionary.

I would really recommend that the book be rewritten by some technical writer.

I agree with Michael. This book is written for Eiffel
programmers. This book does not add anything to GoF,
it just contains more code written in Eiffel.
But for a non Eiffel programmer, the code is not easy to
understand at all. If you need more code for GoF patterns,
and you happen to be a Java programmer or understand Java,
try

Applied Java Patterns
by Stephen A. Stelting, Olav Maassen
ISBN: 0130935387

This book is much more clear and it contains complete code in Java.

If you are a C++ programmer, GoF is still useful.
For VB programmer, there is a good book

Microsoft Visual Basic Design Patterns (Microsoft Professional Series)
by William Stamatakis
ISBN: 1572319577

Dan
Sr. Software Developer,
Sun Certified Java Programmer, Developer
IBM Certified Developer for XML and related technologies