Anneke Kleppe

Bio: Anneke Kleppe is an academic researcher from University of Twente. The author has contributed to research in topics: Object Constraint Language & Semantics (computer science). The author has an hindex of 16, co-authored 23 publications receiving 4629 citations.

MDA Explained: The Model Driven Architecture¿: Practice and Promise

Abstract: From the Book: For many years, the three of us have been developing software using object oriented techniques. We started with object oriented programming languages, like C++, Smalltalk, and Eiffel. Soon we felt the need to describe our software at a higher level of abstraction. Even before the first object oriented analysis and design methods, like Coad/Yourdon and OMT, were published, we used our own invented bubbles and arrows diagrams. This naturally led to questions like "What does this arrow mean?" and "What is the difference between this circle and that rectangle?". We therefore rapidly decided to use the newly emerging methods to design and describe our software. During the years we found that we were spending more time on designing our models, than on writing code. The models helped us to cope with larger and more complex systems. Having a good model of the software available, made the process of writing code easier and in many cases even straightforward. In 1997 some of us got involved in defining the first standard for object oriented modeling called UML. This was a major milestone that stimulated the use of modeling in the software industry. When the OMG launched its initiative on Model Driven Architecture we felt that this was logically the next step to take. People try to get more and more value from their high level models, and the MDA approach supports these efforts. At that moment we realized that all these years we had naturally walked the path towards model driven development. Every bit of wisdom we acquired during our struggle with the systems we had to build, fitted in with this new idea of how to build software. It caused a feeling similar to an AHA-erlebnis: "Yes, this is it," the same feeling we had years before when we first encountered the object-oriented way of thinking, and again when we first read the GOF book on design patterns. We feel that MDA could very well be the next major step forward in the way software is being developed. MDA brings the focus of software development to a higher level of abstraction, thereby raising the level of maturity of the IT industry. We are aware of the fact that the grand vision of MDA, which Richard Soley, the president of the OMG, presents so eloquently, is not yet a reality. However some parts of MDA can already be used today, while others are under development. With this book we want to give you insight in what MDA means and what you can achieve, both today and in the future. Anneke Kleppe, Jos Warmer, and Wim Bast Soest, the Netherlands January 2003

The object constraint language : precise modeling with UML

Abstract: (All chapters conclude with "Summary".) Foreword. Preface. Acknowledgments. Introduction. Who Should Read This Book. How This Book Should Be Used. Typeface Conventions. Information on Related Subjects. 1. Why Write Constraints? Definition of Constraint. Use of Constraints in Other Techniques. Design by Contract. Definition of Contract. Contents of a Contract. Advantages of Contracts. Preconditions and Postconditions. Invariants. Advantages of Constraints. Better Documentation. Improved Precision. Communication without Misunderstanding. Declarative or Operational Constraints. Advantages of a Declarative Language. Notation: Natural Language or Mathematical Expressions. Summary: Requirements for OCL. 2. OCL Basics. The "Royal and Loyal" System Example. Putting Invariants on Attributes. Putting Invariants on Associated Classes. Dealing with Collections of Objects. Sets, Bags, and Sequences. Inheritance. Working with Enumerations. Writing Preconditions and Postconditions. Where to Start Writing Invariants. Broken Constraints. Summary. 3. The Complete Overview of OCL Constructs. Types and Instances. Value Types and Object Types. OCL Expressions and OCL Constraints. The Context of an OCL Expression. The Context of an Invariant. The Context of a Pre- or Postcondition. The self Keyword. Basic Types and Operators. The Boolean Type. The Integer and Real Types. The String Type. Model Types. Attributes from the UML Model. Operations from the UML Model. Class Operations and Attributes from the UML Model. Associations and Aggregations from the UML Model. Association Classes from the UML Model. Qualified Associations from the UML Model. Using Package Names in Navigations. Using Pathnames in Inheritance Relations. Enumeration Types. The Set, Bag, and Sequence Types. Treating Instances as Collections. Flattening Collections. Operations on All Collection Types. Operations with Variant Meaning. Operations for the Set Type. Operations for the Sequence Type. Operations That Iterate over Collection Elements. The select Operation. The reject Operation. The collect Operation. Shorthand Notation for collect. The forAll Operation. The exists Operation. The iterate Operation. Constructs for Postconditions. Operations Defined on Every OCL Type. Types as Objects. Type Conformance Rules. Precedence Rules. Comments. Undefined. Summary. 4. Modeling with Constraints. Constraints in a UML Model. Invariants. Invariants for Derived Attributes or Associations. Preconditions and Postconditions. Guards in State Transition Diagrams. Using Guards and Events in Pre- and Postconditions. Change Events in State Transition Diagrams. Type Invariants for Stereotypes. Where OCL Expressions Can Be Used. Constraints and Inheritance. Styles for Specifying Constraints. Avoiding Complex Navigation Expressions. Choice of Context Object. Use of allInstances. Splitting and Constraints. Adding Extra Operations or Attributes. Using the collect Shorthand. Solving Modeling Issues with Constraints. Abstract Classes. Specifying Uniqueness Constraints. Adding Details to the Model versus Adding Constraints. Cycles in Class Models. Constraints on Associations. Multiplicity Constraints. The Subset Constraint. The Or Constraint. Optional Multiplicity in Associations. Summary. 5. Extending OCL. A Word of Caution. Extending the Standard OCL Types. Adding New OCL Types. Operational Use of Constraints. Generating Code for Constraints. When to Check Constraints. What to Do When the Constraint Fails. Summary. Appendix A. OCL Basic Types and Collection Types. Basic Types. OclType. OclAny. OclExpression. Real. Integer. String. Boolean. Enumeration. Collection-Related Types. Collection. Set. Bag. Sequence. Appendix B. Formal Grammar. Bibliography. Index. 0201379406T04062001

The Object Constraint Language: Getting Your Models Ready for MDA

Abstract: Praise for The Object Constraint Language, Second Edition“MDA promises a revolution in the way we develop software. This book is essential reading for anyone intending to adopt MDA technology.” i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ -Tony Clark, PhD i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ King's College, London“Through examples, Jos and Anneke demonstrate the power and intuitiveness of OCL, and the key role that this language plays in implementing and promoting MDA. The theme, structure, contents, and, not lastly, the clarity of explanations recommend this book as the best advocate for learning, using, and promoting OCL, UML, and MDA. I am sure that this work will contribute in a significant manner to the development and widespread use of new software technologies.” i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ -Dan Chiorean i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ Head of the Computer Science Research Laboratory i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ i¾ Babes-Bolyai University, Cluj"In this thoroughly revised edition, Jos and Anneke offer a concise, pragmatic, and pedagogic explanation of the Object Constraint Language (OCL) and its different applications. Their discussion of OCL's potential role in Model Driven Architecture (MDA) is timely and offers great insight into the way that UML can be taken to the next level of automated software development practice. I highly recommend this book to anyone who is looking to get the most out of UML."-Shane Sendall, PhD, Senior Researcher, Swiss Federal Institute of Technology in LausanneThe release of Unified Modeling Language (UML) 2.0 places renewed emphasis on the Object Constraint Language (OCL). Within UML, OCL is the standard for specifying expressions that add vital information to object-oriented models and other object-modeling artifacts. Model Driven Architecture (MDA) relies on OCL to add the level of programming detail necessary to enable platform-specific models (PSM) to communicate with platform-independent models (PIM).This book is a practical, accessible guide to OCL for software architects, designers, and developers. Much care has been taken during the redesign of OCL to ensure that the syntax remains readable and writable by the average software modeler. The Object Constraint Language, Second Edition, utilizes a case study to show how to exercise these compact but powerful expressions for maximum effect.This newly updated edition Explains why OCL is critical to MDA--and why UML alone is not enough Introduces an SQL-like syntax to OCL Defines the new language constructs of OCL 2.0 Demonstrates how OCL can be incorporated into code Shares tips and tricks for applying OCL to real-world modeling challenges-showing which can be solved with UML and which require OCLUsing a combination of UML and OCL allows developers to realize the effective, consistent, and coherent models that are critical to working with MDA. The authors' pragmatic approach and illustrative use of examples will help application developers come quickly up to speed with this important object-modeling method-and will serve as a ready reference thereafter.

MCC: a model transformation environment

Abstract: In the model driven software development process, software is built by constructing one or more models and transforming these into other models. In turn these output models may be transformed into another set of models until finally the output consists of program code that can be executed. Ultimately, software is developed by triggering an intricate network of transformation executions. An open issue in this process is how to combine different transformation tools in a flexible and reliable manner in order to produce the required output. This paper presents a model transformation environment in which new transformation tools can be plugged in and used together with other available transformation tools. We describe how transformations can be composed. Furthermore, in the cause of answering the question where and how transfor-mations can be successfully applied, we created a language-based taxonomy of model transformation applications.

Defining object-oriented execution semantics using graph transformations

Abstract: In this paper we describe an application of the theory of graph transformations to the practise of language design. In particular, we have defined the static and dynamic semantics of a small but realistic object-oriented language (called TAAL) by mapping the language constructs to graphs (the static semantics) and modelling their effect by graph transformation rules (the dynamic semantics). This gives rise to execution models for all TAAL-programs, which can be used as the basis for formal verification. This work constitutes a first step towards a method for defining all aspects of software languages, besides their concrete syntax, in a consistent and rigorous manner. Such a method facilitates the integration of formal correctness in the software development trajectory.

The unified modelling language reference manual

Abstract: Written by the three pioneers behind the Unified Modeling Language (UML) standard, The Unified Modeling Language Reference Manual provides an excellent real-world guide to working with UML. This title provides expert knowledge on all facets of today's UML standard, helping developers who are encountering UML on the job for the first time to be more productive. The book begins with a history of UML, from structured design methods of the '60s and '70s to the competing object-oriented design standards that were unified in 1997 to create UML. For the novice, the authors illustrate key diagram types such as class, use case, state machine, activity, and implementation. (Of course, learning these basic diagram types is what UML is all about. The authors use an easy-to-understand ticket-booking system for many of their examples.) After a tour of basic document types, The Unified Modeling Language Reference Manual provides an alphabetical listing of more than 350 UML terms. Entries range from a sentence or two to several pages in length. (Class, operation, and use case are just a few of the important terms that are covered.) Though you will certainly need to be acquainted with software engineering principles, this reference will serve the working software developer well. As the authors note, this isn't UML for Dummies, but neither is it an arcane academic treatise. The authors succeed in delivering a readable reference that will answer any UML question, no matter how common or obscure. --Richard Dragan

Software Abstractions: Logic, Language, and Analysis

Abstract: In Software Abstractions Daniel Jackson introduces an approach to software design that draws on traditional formal methods but exploits automated tools to find flaws as early as possible. This approach--which Jackson calls "lightweight formal methods" or "agile modeling"--takes from formal specification the idea of a precise and expressive notation based on a tiny core of simple and robust concepts but replaces conventional analysis based on theorem proving with a fully automated analysis that gives designers immediate feedback. Jackson has developed Alloy, a language that captures the essence of software abstractions simply and succinctly, using a minimal toolkit of mathematical notions. This revised edition updates the text, examples, and appendixes to be fully compatible with the latest version of Alloy (Alloy 4). The designer can use automated analysis not only to correct errors but also to make models that are more precise and elegant. This approach, Jackson says, can rescue designers from "the tarpit of implementation technologies" and return them to thinking deeply about underlying concepts. Software Abstractions introduces the key elements: a logic, which provides the building blocks of the language; a language, which adds a small amount of syntax to the logic for structuring descriptions; and an analysis, a form of constraint solving that offers both simulation (generating sample states and executions) and checking (finding counterexamples to claimed properties).

Smart Dust: communicating with a cubic-millimeter computer

Abstract: Domain-specific integrated development environments can help capture specifications in the form of domain models. These tools support the design process by automating analysis and simulating essential system behavior. In addition, they can automatically generate, configure, and integrate target application components. The high cost of developing domain-specific, integrated modeling, analysis, and application-generation environments prevents their penetration into narrower engineering fields that have limited user bases. Model-integrated computing (MIC), an approach to model-based engineering that helps compose domain-specific design environments rapidly and cost effectively, is particularly relevant for specialized computer-based systems domains-perhaps even single projects. The authors describe how MIC provides a way to compose such environments cost effectively and rapidly by using a metalevel architecture to specify the domain-specific modeling language and integrity constraints. They also discuss the toolset that implements MIC and describe a practical application in which using the technology in a tool environment for the process industry led to significant reductions in development and maintenance costs.

Alloy: a lightweight object modelling notation

Abstract: Alloy is a little language for describing structural properties. It offers a declaration syntax compatible with graphical object models, and a set-based formula syntax powerful enough to express complex constraints and yet amenable to a fully automatic semantic analysis. Its meaning is given by translation to an even smaller (formally defined) kernel. This paper presents the language in its entirety, and explains its motivation, contributions and deficiencies.