The Object Constraint Language: Precise Modeling with UML

To manage large computing projects, we need two things. Precise languages and the will to use them. While the Unified Modeling Language (UML) is a valuable addition to our tool set, it is limited when used to describe and restrict the behavior of our objects. The Object Constraint Language (OCL) allows for the formal description of constraints on the data to be used. Given the ability to write specific constraints on information, it is then possible to use a design by contract model in the creation of software. The advantages of such a model are obvious, in that so much of our personal and professional lives are based on contracts, albeit most are informal. Professional interactions that take place in the creation of complex software are also contracts. I have participated in many discussions of the form, "You construct this function so that it does this and I will use it to do the other thing." However, so much of this is informal, which leads to disagreements over interpretations. It is for this reason that I have long argued that the real increase in productivity from the use of formal languages will be a reduction in the amount of time needed to settle disputes over ambiguities. While some exposure to the principles of formal logic will be helpful, it is not necessary to understand the material of the book. Knowledge of basic Boolean expressions will suffice. As the title suggests, the UML is used as the basis for the OCL. The use of the similar notation and terminology really simplifies the approach, making it very easy to pick up. I was most impressed with the OCL as well as the explanatory style used in the book, although I must confess to having a bias towards formal languages in computing. After reading the book, I came away with an even greater appreciation for the power of formal languages, which given my nearly two decades of exposure to them, is not an easy task. The design by contract model of computing is a very powerful mechanism whereby ambiguity can be removed from the design and implementation process. To do it properly, a formal language such as OCL is needed and this book will teach it to you in the minimal amount of time.

OCL is an attempt to bring a formal method into the "real world" by making the syntax non-mathematical and - in this book - describing and illustrating it in the context of developing a realistic app using UML.The book is short, trustworthy and rewarding - the more you work at it the more you understand, and I only spotted one typo (apart from appendix A.2, which is apparently borrowed from the OMG, and has a few). It makes a compelling case for using OCL to disambiguate the UML, and also supports the (unstated) observation - the paradox of formal methods is that they are highly counter-intuitive to the ordinary application developer, but have the potential to make development much more intuitive by ensuring that software components work as designed, separately and together.

An excellent book with good examples and without smoth talk and stupid dedication (such as "To my love" or "To lord Jesus Christ" !). It shows to non mathematican (so I am) that's possible to use formal descriptions during analysis and design in a better way than informal comments. Let's hope that tools will support this language and generate controls in code even if we don't use Eiffel.

First, I like this book. I trust about every line of it. It is itself precise or at least as precise as possible. It summarizes things in a concise and complete way. Required prior knowledge is UML (of course). I'd recommend Fowler's beautiful UML distilled and also even more important a solid understanding of design by contract. I recommend the complete book of Bertrand Meyer "Object Oriented Software Construction". Yes I know its many month of reading.The problem with this OCL book is the following: It is difficult to understand anything not prior understood. However once one has a grasp of understanding this book is really clarifying. So, it requires in many areas more maturity in the field than most of us including me have. So, I would wish a book, which starts of at a somewhat lower level, in a less dry diction.

The OCL is a defined, typed grammar for the accurate expression of constraints and rules that will prove very useful in the construction of object-oriented tools and end-user systems. It provides a valuable extension and compliment to the strengths of the UML. The text is detailed, in-depth and very interesting in its presentation of the problem domain.