Marco Comini

Abstract Diagnosis of Functional Programs

We present a generic scheme for the declarative debugging of functional programs modeled as term rewriting systems. We associate to our programs a semantics based on a (continuous) immediate consequence operator, \( T_\mathcal{R} \), which models the (values/normal forms) semantics of \( \mathcal{R} \) . Then, we develop an effective debugging methodology which is based on abstract interpretation: by approximating the intended specification of the semantics of \( \mathcal{R} \) we derive a finitely terminating bottom-up diagnosis method, which can be used statically. Our debugging framework does not require the user to either provide error symptoms in advance or answer questions concerning program correctness. We have made available a prototypical implementation in Haskell and have tested it on some non trivial examples.

A Theory of Observables for Logic Programs

We define a semantic framework to reason about properties of abstractions of SLD-derivations. The framework allows us to address problems such as the relation between the (top-down) operational semantics and the (bottom-up) denotational semantics, the existence of a denotation for a set of definite clauses and their properties (compositionality w.r.t. various syntactic operators, correctness, minimality, and precision). Using abstract interpretation techniques to model abstraction allows us to state very simple conditions on the observables which guarantee the validity of several general theorems.

Proving Properties of Logic Programs by Abstract Diagnosis

We show how declarative diagnosis techniques can be extended to cope with verification of operational properties, such as computed answers, and of abstract properties, such as types and groundness dependencies. The extension is achieved by using a simple semantic framework, based on abstract interpretation. The resulting technique (abstract diagnosis) leads to elegant bottom-up and top-down verification methods, which do not require to determine the symptoms in advance, and which are effective in the case of abstract properties described by finite domains.

Abstract Debugging of Logic Program

Our debugging method applies to positive logic programs, under the leftmost selection rule. All our results can easily be extended to local selection rules [27].

A Minimalist Visual Notation for Design Patterns and Antipatterns

Achieving a quality software system requires UML designers to have a good understanding of both design patterns and antipatterns. Unfortunately, UML models for real systems tend to be huge and hard to manage, especially for models automatically generated from source code. Thus, it would be advisable to have tools to automatically identify particular instances of patterns. So, a formal language to express them is needed. However, a textual formalization of such a language is barely usable by UML practitioners. In this paper we propose a visual notation obtained by adding to UML as few graphical elements as possible in order to express both patterns and antipatterns (with the needed formality). This approach has low cognitive load so is easily usable by practitioners but is still rigorous enough for implementation. This notation will be exploited by a GUI front-end for a prototypical tool (that we have recently developed) which is able to discover (anti)patterns in models.

A Rule-based Method to Match Software Patterns Against UML Models

In a UML model, different aspects of a system are covered by different types of diagrams and this bears the risk that an overall system specification becomes barely tractable by the designer. When the model grows, it is likely that the architectural integrity will be compromised by extensions and bug-fixing operations. Hence, it is important to provide means to help designers to search in big models for particular instances of some variable schema of UML models (design patterns) they construct. This can help them both to find potential problems in the architecture design and to ensure that intended architectural choices had not been broken by mistake. In this paper we propose a rule-based method to find matches of design patterns into a UML model. The method is general enough to tackle most patterns and antipatterns.

Compositionality properties of SLD-derivations

Abstract The paper introduces a semantics for definite logic programs expressed in terms of SLD -derivations and studies various properties of SLD -derivations by using the above semantics. The semantics of a program is a goal-independent denotation, which can equivalently be specified by a denotational semantics and a transition system. The denotation is proved to be correct, minimal, AND -compositional and OR -compositional. The denotational semantics and the transition system are defined in terms of a set of primitive semantic operators, whose properties are directly related to the properties of the denotation. The SLD -derivations semantics has been designed to act as collecting semantics for a framework of abstract semantics (Comini et al., 1995, 1996).

Abstract diagnosis of first order functional logic programs

We present a generic scheme for the abstract debugging of functional logic programs. We associate to programs a semantics based on a (continuous) immediate consequence operator, P[R], which models correctly the powerful features of modern functional logic languages (non-deterministic, non-strict functions defined by non-confluent programs and call-time choice behaviour). Then, we develop an effective debugging methodology which is based on abstract interpretation: by approximating the intended specification of the semantics of R we derive a finitely terminating bottom-up diagnosis method, which can be used statically. Our debugging framework does not require the user to provide error symptoms in advance and is applicable with partial specifications and even partial programs.

Assertion based Inductive Verification Methods for Logic Programs

Abstract This paper is an overview of our results on the application of abstract interpretation concepts to the derivation of a verification method for logic programs. These include the systematic design of semantics modeling various proof methods and the characterization of assertions as abstract domains. We first apply the verification framework defined in [5] to derive inductive sufficient conditions for partial correctness. Then the domain of assertions is formalized as an abstract domain. We can therefore derive an assertion based verification method. We finally show two methods based on different assertion languages: a decidable assertion language and Horn clause logic used as assertion language.

Abstract Diagnosis for tccp using a Linear Temporal Logic

Automatic techniques for program verication usually suer the wellknown state explosion problem. Most of the classical approaches are based on browsing the structure of some form of model (which represents the behavior of the program) to check if a given specication is valid. This implies that a part of the model has to be built, and sometimes the needed fragment is quite huge. In this work, we provide an alternative automatic decision method to check whether a given property, specied in a linear temporal logic, is valid w.r.t. a tccp program. Our proposal (based on abstract interpretation techniques) does not require to build any model at all. Our results guarantee correctness but, as usual when using an abstract semantics, completeness is lost.