Abstract. The paper presents the essential features of a new member of the UML language family that supports working with object-oriented frameworks. This UML extension, called UML-F, allows the explicit representation of framework variation points. The paper discusses some of the relevant aspects of UML-F, which is based on standard UML extension mechanisms. A case study shows how it can be used to assist framework development. A discussion of additional tools for automating framework implementation and instantiation rounds out the paper. 1

Based on experiences gained from an embedding of the Object Constraint Language (OCL) in higher-order logic [1], we explore several key issues of the design of a formal semantics of the OCL. These issues comprise the question of the interpretation of invariants, pre- and postconditions, an executable sub-language and the possibilities of refinement notions. A particular emphasize is put on the issue of mechanized deduction in UML/OCL specification.

... is to make UML models more precise and unambiguous by providing a constraint language describing constraints that the UML diagrams alone do not convey, including class invariants, operation contracts, and statechart guard conditions. There is an ongoing debate regarding the usefulness of using OCL in UML-based development, questioning whether the additional effort and formality is worth the benefit. It is argued that natural language may be sufficient, and using OCL may not bring any tangible benefits. This debate is in fact similar to the discussion about the effectiveness of formal methods in software engineering, but in a much more specific context. This paper presents the results of two controlled experiments that investigate the impact of using OCL on three software engineering activities using UML analysis models: detection of model defects through inspections, comprehension of the system logic and functionality, and impact analysis of changes. The results show that, once past an initial learning curve, significant benefits can be obtained by using OCL in combination with UML analysis diagrams to form a precise UML analysis model. But, this result is however conditioned on providing substantial, thorough training to the experiment participants.

We propose a visualization of OCL within the context of the UML meta model, so that OCL expressions are represented by extending collaboration diagrams. We exploit the OCL meta model introduced in [9] and further elaborated on in [1] and base the description of properties of objects on collaborations, while classifier and association roles are used to describe navigation paths. Operations computing properties are described by interactions consisting of messages between classifier roles. The introduction of new graphical core elements is kept to a minimum. New notation mainly concerns the prede ned operations in OCL and provides more convenient visual forms for the notation by interactions here. The proposed visualization is described in detail and is illustrated with examples taken from an industrial project under development.

The aim of this paper is to provide an approach for a better reification of the semantics of the access control mechanisms within the OFL Model. OFL is a meta-model dedicated to the description of object-oriented programming languages. The description of the semantics of language is achieved through the customization of a set of language features. Originally this customization can deal only with features which must be general enough for being applicable to most existing objectoriented programming languages. But further experiences point out the necessity to capture more semantics and also to handle semantics which is specific to one language. In this paper we describe an extension of the OFL model which addresses this issue and we apply it to the description of access control semantics which are most of the time very language dependent.

Abstract not found

Abstract. In this paper we propose an equational specification of UML+OCL static class diagrams that provides a formal foundation for automatically validating UML object diagrams with respect to OCL constraints. Basically, class and object UML diagrams are specified as membership equational theories, and OCL expressions are represented as terms over extensions of those theories. Then, validating object diagrams with respect to invariants is reduced to checking whether the corresponding terms rewrite to true or false. Based on these ideas, we have developed a tool, named ITP/OCL, that provides automatic validation of object diagrams with respect to OCL constraints. 1

Abstract We report on the results of a long-term project to formalize the semantics of OCL 2.0 in Higher-order Logic (HOL). The ultimate goal of the project is to provide a formalized, machine-checked semantic basis for a theorem proving environment for OCL (as an example for an objectoriented specification formalism) which is as faithful as possible to the original informal semantics. We report on various (minor) inconsistencies of the OCL semantics, discuss the more recent attempt to align the OCL semantics with UML 2.0 and suggest several extensions which make, in our view, OCL semantics more fit for future extensions towards program verifications and specification refinement, which are, in our view, necessary to make OCL more fit for future extensions. 1

The paper addresses the problems of making program specifications written in OCL easier to read and to maintain. The solution proposed is to use the grammar formalism GF to define a high-level abstract grammar of specifications with translations into OCL, logic, and natural languages. A prototype of the solution is illustrated by an example. 1 Introduction Recent work on the Object Constraint Language [11,18] includes suggestions for formal semantics [8,6,13,15,16] and attempts at a closer integration with other parts of the UML [14,2]. Less attention has been paid so far to the relationship between OCL and the language, in which most software specifications are still written: natural language (NL). As the usage of formal and semi-formal specification languages is becoming more widespread, this conceptual gap between NL specifications and (semi)- formal specifications becomes a significant obstacle to further development. We see the following problems arising: -- Formal Specifi...

Abstract. Within the setting of object-oriented program specification and verification, pointers and object references can be considered as relations between the elements of a data structure. When we specify properties of these data structures, we often describe properties of relations. Hence it is important to be able to talk about relations and their properties when specifying object-oriented programs or programs with pointers. Many interesting properties of relations such as transitive closure, finiteness, and generatedness are not expressible in first-order logic (FOL); hence neither are they expressible in first-order fragments of specification languages. In this paper we give an overview of the different ways such properties can be expressed in various logics, with a particular emphasis on extensions of FOL, i.e. transitive closure logic, fixed-point logic, and first-order dynamic logic. Within the paper we also discuss which of these extensions already are – or in fact should be – implemented within specification languages. We feel that such a discussion is necessary since it is often the case that when an extension of FOL is implemented within a specification language it is done so in an ad hoc manner or the underpinning logical concepts are not well documented.. 1