The Object Constraint Language: Getting Your Models Ready for MDA

by Jos B. Warmer and Anneke G. Kleppe

Book Overview

This guide explains how to add object constraint language (OCL) expressions to UML models, generate Java code from a combined UML/OCL model, and use OCL to define transformations for the model driven... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0321179366
• ISBN13: 9780321179364
• Release Date: August 2003
• Publisher: Addison-Wesley Professional
• Length: 206 Pages
• Weight: 0.95 lbs.
• Dimensions: 0.6" x 7.0" x 9.2"

Customer Reviews

Effective use of mathematics to describe code

As a mathematician, I have always been drawn to the more formal programming methods of the Object Constraint Language (OCL). With it, you can place precise mathematical descriptions of what must be true before the code executes and what is guaranteed to be true after the code has run. Given the concise nature of mathematical notation, the OCL expressions also can replace many times their text in comments. The combination of Unified Modeling Language (UML) and OCL is a powerful one, allowing you to precisely describe the actions that code is expected to perform. However, the OCL is unlike other formal mathematical languages in that it must change in response to new ways of creating code. One of the newest ways to design software systems is to use Model Driven Architectures (MDAs). An MDA is a high level framework that describes how models can be translated from language to language. Since the purpose is to allow for the translation to be done by machine, it is necessary for all restrictions to be written in a clear, unambiguous manner. Currently, the MDA process is divided into three steps: The Platform Independent Model (PIM), which is at the highest level of abstraction and is independent of any specific technology. The PIM is then translated into one or more Platform Specific Models (PSMs), where platform specific features are incorporated into each PSM. Each PSM is then converted into code to be run on the specific platform. When I first encountered the fundamentals of MDAs, my skepticism meter rose to a high level. Even with the precision of UML, creating accurate models is very hard, and creating appropriate code from those models is probably harder. Sure, it is possible to create the constructors, setters and getters and other simple components of a class automatically, but code is so complex that it is difficult to look at a model and know precisely what it is supposed to do. After reading this book, the level of my skepticism meter has dropped quite a bit. From the presentation, it is easy to see how important OCL is to the accurate rendition of code from models. In fact, it is hard to believe that MDA could possibly succeed without OCL being heavily incorporated into the models. The opening chapter of the book is a brief explanation of MDAs and how UML and OCL are used in combination to create the models. A solid introduction to the MDA way of doing things, it also describes the foundations, but not the specifics of OCL. It is assumed that the reader is familiar with the UML. In chapter two, the OCL is described using an example of a customer loyalty program. This is an excellent example, as it is easy to understand and allows most of the basic expressions of the OCL to be used. Chapter three is where the specifics of how the OCL is used in models are covered. While the examples are well done, one does not skim this chapter and understand it. The combination of diagrams and constraints must be read with a great deal of care in

OK for experienced programmers

This book really is for experienced programmers. It presupposes a strong familiarity with UML, and even some knowledge of MDA. Given that, the reader should be able to place the OCL within the UML framework. The example used throughout the book is helpful, since it gives a moderately realistic setting showing how OCL describes real application logic.Experienced programmers will also be able to unwind the non-intuitive order of presentation. The book starts with the examples, giving a rough idea of OCL's relationship to the more familiar UML class, object, state, and interaction diagrams. Next, it shows how the OCL can be rendered in Java langauge syntax, and finally the OCL language is presented. I would much rather have seen the language definition, then the example, then the sample langauge binding - a beginner is likely to need at least two or three readings to resolve all of the book's implicit forward references.It will also take an experienced programmer to step over the book's occasional errors. For example, pp49-50 seem to confuse inclusive and exclusive OR semantics. An example on p.86 first confuses the Java equality test and assignment operators, then confuses object identity and value equality testing. An experienced reader will also forgive erratic editing, such as p.97's reference to a banana's "peal." (As a matter of record, I tried pealing a banana the way I would peal a bell and got disappointing results.)Most of all, it will take an experienced reader to sort out the different meta-levels of representation. At different times, the OCL is presented as a tool that talks about the model of the program and as a tool that specifies the content of the program. I can go either way or both ways, but a beginner would probably get lost at one meta-level or another. Experienced programmers will also forgive the vague connection between the OCL and other parts of the UML standard. Those connections are very tool-dependent, and the tools don't exist yet.This is about the first book on OCL, though, so I have to cut some slack for it. The OCL is an advanced part of the "Model Description Architecture". The MDA is so advanced that it doesn't even exist at this writing, in any way a programmer can use. I'm sure that, once the MDA becomes common in the field, more effective OCL teaching tools will also appear. Until then, this is an interesting, if somewhat murky peek into the future of software methodology.

Added value

The Object Constraint Language Second Edition written by Anneke Kleppe and Jos Warmer, explains in no time, how to complete your Platform Independent Models, with business and query language. The UML2.0 renewed emphasis on the Object Constraint Language extends the functionality needed to model more, and to program less.This book focuses on the Business Rules implementation in MDA, and brings the details needed.Step by step the book explains the OCL language and provides the reader with the knowledge to use OCL from a MDA point of view using transformation examples translating OCL to Java business rules.This book can be considered as "Added value", also when readers are already familiar with the book 'MDA Explained The Model Driven Architect Practice and Promise book written by Anneke Kleppe, Jos Warmer and Wim Bast'.The overlap is small.Using the theory from the books, I succeeded in writing a bridge from Uniface to UML using XMI and visa versa.In MDA terminology we transform a Platform Independent Model (PIM) to a Platform Specific Model (PSM).We translate an Object Oriented Model to a Entity Relationship Model, including the OCL translation to simple business rules.Have fun reading

Take your Software Engineering Skills to the next level

This books thru explanations, clear and concrete examples and a concise case study shows the reader how to take your software engineering skills to the next level. It shows practical uses and examples of the concepts that you leaned while studying Object Oriented concepts in school. For the Computer Scientists, this book is one smile after another of how some things that you always thought was great in concept have showed up in the real world. For a book that's less than 300 pages long, it sure compacts lots of information in there. This was my encounter with the Object Constraint Language, or OCL. I have been using UML for work for a number of years now, but I never gave OCL a second thought other than a "nice-to-have-conpcept-that-makes-your-life-harder-than-its-worth" type of technology. This book was an eye opener. I am really glad that I took the time to real this book. The book has three major parts: 1) User manual2) Reference Manual3) AppendicesBy looking at the TOC, one is not really impressed. User manual? Reference Manual? I thought I am going to be bored to no end while reading this book. The TOC does not do justice to the book. The author in chapter 1 introduces MDA and its benefits (Portability, Productivity, Cross-platform interoperability, and easier maintenance and documentation). The author then introduces the concept of Modeling Maturity Levels (MML), which is very similar to the CMM levels for Software Engineering. MML has five levels and is used as an indication of, "...what role models play in your software development process, and the direction you need to take to improve this process."i) Level 0: No Specification. Add-hoc developmentii) Level 1: Textual. Specs written in one or more natural language documentsiii) Level 2: Text with Diagrams. Several high-level diagrams are added to explain the over-all architectureiv) Level 3: Models with Text. Models with a very specific and well-defined meaning, forms the specification of the softwarev) Level 4: Precise Models. "A Model, meaning a consistent and coherent set of texts and/or diagrams with a very specific and well-defined meaning, specifies the software" vi) Level 5: Models only. There will only be models and that is all. Level 4, which is where MDA is targeted towards, is enabled only thru the use of a language such as OCL. I have never heard or seen anything on MML, but I certainly hope that people start using it more b/c it clearly explains an organization's software development process maturity. In the rest of the chapters of part 1, the author goes thru extensive set of examples showing how to use OCL. Chapter 2, titled "OCL By Example" is a case study of what is referred to as a "Royal & Loyal" application in which there are tons of short, long, beginner, advanced, and everything in the middle types of examples. One example of a concept that you would love to apply in the real world is the concept of "Design by Contract" (Chapter 3, page 43