This book treats about the technique for designing and implementing object oriented software based in contracts, then it is intended for students and software developers who are looking for design and coding methodologies that allows them to develop more reliable applications. Like the preface of the book mentions, design of software with contracts is “all about adding assertions to object oriented programs”, so the authors are treating about the art of writing preconditions, postconditions and invariants, based on six principles and some guidelines well founded along twelve chapters and practical examples. The reader is really encouraged to interact with the book by putting in practice the examples that are formulated by a clear way. Design by contracts is oriented to the design level of software, not withstanding, the last part of book exposes like contracts can be used in analysis based in use cases. Chapters 1, 2, and 3 are the foundation for ideas proposed on this book, since they make the presentation of the six principles for design by contracts and the way like these must be applicated. It is gave special attention to the definition of query and comand concepts like the base for the formulation of the principles. Two classical examples, the first one, the design of a class to manage generic stacks, and the second one, a dictionary class, are simple enough, and complete at the same time, to make a first explanation of what Mitchell and McKim are thinking about writing contracts. Example in chapter 4 develops a class for inmutable lists to support contracts in other classes. Chapter 5 makes use of this class to solve with contracts a classical linear structure like queue. It is really interesting the fact of focusing this common kind of problems from this point of view. After reading chapter 5, readers will get to undertand the concept about “classes to support contracts in other classes”, presented by the authors. Chapter 6 treat about questions related to inheritance and contracts, it is useful for people who are writing classes to be used like superclasses because they will find details about how making contracts able to be redefined in future implementations, and from the other side, people who are writing subclasses will know how redefine contracts from superclasses. Developers not familiarized with contracts could confuse design by contracts with defensive programming while reading the book, that is the motivation because in chapter 8 it’s made a comparison between both them, moreover are showed the benefits of writing contracts. Maybe it could be a good thing if those benefits were presented on first chapters to clarify the concepts. People working with object oriented frameworks must pay attention to chapter 9, because it’s made an approach to the observer design pattern by contracts. The purpose is to show that design by contracts is applicable to collaborating classes schemes; furthermore there is a section related to frame rules that helps to understand a little more chapter 7, also it’s treated the privacy requirements related to contracts when inheriting classes. Chapter 10 is dedicated to the verification of fullfilling preconditions based on a simple counter example. The examples are presented using UML notation and principally are based on Eiffel language, because it offers native support for contracts. In Chapter 11, some examples are developed with Java making use of a preprocessor called iContract. Though examples wrote with Eiffel aren’t complicated to understand, C++ developers like me will feel more comfort looking Java examples considering the similitude with C++, not withstanding the authors don’t make a precision about preprocessors for C++ compilers. Vast experience of the authors in the field of object oriented software is a plus, this is a book made by developers for developers, so it could be really useful for people worry about getting better designs, documentation and reliability with an extra time effort.