Isabel Nunes

Checking the conformance of java classes against algebraic specifications

We present and evaluate an approach for the run-time conformance checking of Java classes against property-driven algebraic specifications. Our proposal consists in determining, at run-time, whether the classes subject to analysis behave as required by the specification. The key idea is to reduce the conformance checking problem to the runtime monitoring of contract-annotated classes, a process supported today by several runtime assertion-checking tools. Our approach comprises a rather conventional specification language, a simple language to map specifications into Java types, and a method to automatically generate monitorable classes from specifications, allowing for a simple, but effective, runtime monitoring of both the specified classes and their clients.

Bridging the Gap between Algebraic Specification and Object-Oriented Generic Programming

Although generics became quite popular in mainstream object- oriented languages and several specification languages exist that support the description of generic components, conformance relations between object-oriented programs and formal specifications that have been established so far do not address genericity. In this paper we propose a notion of refinement mapping that allows to define correspondences between parameterized specifications and generic Java classes. Based on such mappings, we put forward a conformance notion useful for the extension of ConGu, a tool-based approach we have been developing to support runtime conformance checking of Java programs against algebraic specifications, so that it becomes applicable to a more comprehensive range of situations, namely those that appear in the context of a typical Algorithms and Data Structures course.

An OCL Extension for Low-Coupling Preserving Contracts

Design by contract, as introduced by B.Meyer, is of increasing importance to the OO community in the specification, reuse, and monitoring of classes. We strongly feel that class libraries of all programming languages should be equipped with contracts, insofar as these constitute a powerful and simple interface definition. Very powerful and expressive contracts can be written using the OCL language, although for operations with many effects on the system state, these contracts can become unmanageable and incomprehensible. In order to maintain contracts at a manageable level of complexity, we claim that the OCL powerful mechanism of navigation through associations should be used moderately when building contracts, and that the effects of non-query operations should be allowed to be referred to within pre- and post-conditions. To achieve that purpose, we propose an extension to OCL and present a formal semantics for it.

Design by Contract Using Meta- Assertions

Contract writing for methods in classes that are clients of other classes can bring undesirable effects, like the increasing in class coupling and encapsulation decreasing. We propose a pattern to the design of class contracts that helps producing contracts that preserve low class coupling and data encapsulation. The expressive power of existing assertion languages is insufficient, however, to write these contracts. In order to fill this lack we propose meta-assertions, and we define rules for a grammatically and semantically sound expansion of meta-assertions in order to be able to monitor contracts at run-time using already existing tools.

repAIrC: A Tool for Ensuring Data Consistency

Consistency of knowledge repositories is of prime importance in organization management. Integrity constraints are a well-known vehicle for specifying data consistency requirements in knowledge bases; in particular, active integrity constraints go one step further, allowing the specification of preferred ways to overcome inconsistent situations in the context of database management. This paper describes a tool to validate an SQL database with respect to a given set of active integrity constraints, proposing possible repairs in case the database is inconsistent. The tool is able to work with the different kinds of repairs proposed in the literature, namely simple, founded, well-founded and justified repairs. It also implements strategies for parallelizing the search for them, allowing the user both to compute partitions of independent or stratified active integrity constraints, and to apply these partitions to find repairs of inconsistent databases efficiently in parallel.

Computing Repairs from Active Integrity Constraints

Repairing an inconsistent knowledge base is a well known problem for which several solutions have been proposed and implemented in the past. In this paper, we start by looking at databases with active integrity constraints - consistency requirements that also indicate how the database should be updated when they are not met - as introduced by Caroprese et al.We show that the different kinds of repairs considered by those authors can be effectively computed by searching for leaves of specific kinds of trees. Although these computations are in general not very efficient (deciding the existence of a repair for a given database with active integrity constraints is NP-complete), on average the algorithms we present make significant reductions on the number of nodes in the search tree. Finally, these algorithms also give an operational characterization of different kinds of repairs that can be used when we extend the concept of active integrity constraints to the more general setting of knowledge bases.

Description Logics, Rules and Multi-context Systems

The combination of rules and ontologies has been a fertile topic of research in the last years, with the proposal of several different systems that achieve this goal. In this paper, we look at two of these formalisms, Mdl-programs and multi-context systems, which address different aspects of this combination, and include different, incomparable programming constructs. Despite this, we show that every Mdl-program can be transformed in a multi-context system, and this transformation relates the different semantics for each paradigm in a natural way. As an application, we show how a set of design patterns for multi-context systems can be obtained from previous work on Mdl-programs.

Coordination Durative Actions

A computing paradigm is presented for coordinating the execution of durative actions, i.e. actions which, although executed atomically on a private local state, have a duration in the sense that the system state in which they finish executing is not necessarily the same in which they started. Just as in traditional coordination languages, the coordination model that is responsible for controlling the interference between the actions is independent from the computation model in which actions execute. This coordination model is formalised through an operational and a denotational semantics, both parameterised by those of the underlying computational model.

Integrity Constraints for General-Purpose Knowledge Bases

Integrity constraints in databases have been studied extensively since the 1980s, and they are considered essential to guarantee database integrity. In recent years, several authors have studied how the same notion can be adapted to reasoning frameworks, in such a way that they achieve the purpose of guaranteeing a systems consistency, but are kept separate from the reasoning mechanisms. In this paper we focus on multi-context systems, a general-purpose framework for combining heterogeneous reasoning systems, enhancing them with a notion of integrity constraints that generalizes the corresponding concept in the database world.

Information Flow within Relational Multi-context Systems

Multi-context systems (MCSs) are an important framework for heterogeneous combinations of systems within the Semantic Web. In this paper, we propose generic constructions to achieve specific forms of interaction in a principled way, and systematize some useful techniques to work with ontologies within an MCS. All these mechanisms are presented in the form of general-purpose design patterns. Their study also suggests new ways in which this framework can be further extended.