Reasoning with Spider Diagrams

Spider diagrams combine and extend Venn diagrams and Euler circles to express constraints on sets and their relationships with other sets. These diagrams can usefully be used in conjunction with object-oriented modelling notations such as the Unified Modelling Language. This paper summarises the main syntax and semantics of spider diagrams and introduces four inference rules for reasoning with spider diagrams and a rule governing the equivalence of Venn and Euler forms of spider diagrams. This paper also details rules for combining two spider diagrams to produce a single diagram which retains as much of their combined semantic information as possible and discusses disjunctive diagrams as one possible way of enriching the system in order to combine spider diagrams so that no semantic information is lost

Semantics Through Pictures: towards a diagrammatic semantics for object-oriented modelling notations

An object-oriented (OO) model has a static component, the set of allowable snapshots or system states, and a dynamic component, the set of filmstrips or sequences of snapshots. Diagrammatic notations, such as those in UML, each places constraints on the static and/or dynamic models. A formal semantics of OO modeling notations can be constructed by providing a formal description of (i) sets of snapshots and filmstrips, (ii) constraints on those sets, and (iii) the derivation of those constraints from diagrammatic notations. In addition, since constraints are contributed by many diagrams for the same model, a way of doing this compositionally is desirable. One approach to the semantics is to use first-order logic for (i) and (ii), and theory inclusion with renaming, as in Larch, to characterize composition. A common approach to (iii) is to bootstrap: provide a semantics for a kernel of the notation and then use the kernel to give a semantics to the other notations. This only works if a kernel which is sufficiently expressive can be identified, and this is not the case for UML. However, we have developed a diagrammatic notation, dubbed constraint diagrams, which seems capable of expressing most if not all static and dynamic constraints, and it is proposed that this be used to give a diagrammatic semantics to OO models

A deductive and typed object-oriented language

In this paper we introduce a logical query language extended with object-oriented typing facilities. This language, called DTL (from DataTypeLog), can be seen as an extension of Datalog equipped with complex objects, object identities, and multiple inheritance based on Cardelli type theory. The language also incorporates a very general notion of sets as first-class objects. The paper offers a formal description of DTL, as well as a denotational semantics for DTL programs

Constraint Diagrams: Visualizing Assertions in OO Modelling

Describes a notation, constraint diagrams, which allows pre/post conditions and invariants to be expressed visually, rather than in the notation of mathematical logic. The notation is explored through a small case study (a library system). Some conclusions are drawn about the use of the notation in modelling, and its possible impact on tools and semantics. This report has been split into two and considerable revised and updated: Kent (1997b), Kent (1997c)

Asynchronous data retrieval from an object-oriented database

We present an object-oriented semantic database model which, similar to other object-oriented systems, combines the virtues of four concepts: the functional data model, a property inheritance hierarchy, abstract data types and message-driven computation. The main emphasis is on the last of these four concepts. We describe generic procedures that permit queries to be processed in a purely message-driven manner. A database is represented as a network of nodes and directed arcs, in which each node is a logical processing element, capable of communicating with other nodes by exchanging messages. This eliminates the need for shared memory and for centralized control during query processing. Hence, the model is suitable for implementation on a multiprocessor computer architecture, consisting of large numbers of loosely coupled processing elements

Designing Software Architectures As a Composition of Specializations of Knowledge Domains

This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: ‘A software architecture should be a composition of specializations of knowledge domains’. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience

Updates in a Rule based Language for Objects

The integration of object-oriented concepts into deductive databases has been investigated for a certain time now. Various approaches to incorporate updates into deduction have been proposed. The current paper presents an approach which is based on object versioning; different versions of one object may be created and referenced during an update-process. By means of such versions it becomes possible to exert explicit control on the update process during bottom-up evaluation in a rather intuitive way. The units for updates are the result sets of base methods, i.e. methods, whose results are stored in the object-base and are not defined by rules. However, the update itself may be defined by rules. Update-programs have fixpoint semantics; the fixpoint can be computed by a bottom-up evaluation according to a certain stratification

Automated Verification of Design Patterns with LePUS3

Specification and [visual] modelling languages are expected to combine strong abstraction mechanisms with rigour, scalability, and parsimony. LePUS3 is a visual, object-oriented design description language axiomatized in a decidable subset of the first-order predicate logic. We demonstrate how LePUS3 is used to formally specify a structural design pattern and prove (‗verify‘) whether any JavaTM 1.4 program satisfies that specification. We also show how LePUS3 specifications (charts) are composed and how they are verified fully automatically in the Two-Tier Programming Toolkit