Browsing by Author "Nunes, Isabel"
Now showing 1 - 9 of 9
Results Per Page
Sort Options
- Achieving tightness in dl-programsPublication . Cruz-Filipe, Luis; Nunes, Isabel; Engracia, Patricia; Gaspar, GraçaIn the field of the combination between description logics and rule-based reasoning systems, dl- programs have proved to be a very successful mechanism. One of their recognized shortcomings, however, is their lack of full tightness: the language constructs that feed data from the logic program have a local effect, leaving the knowledge base essentially unchanged throughout. In this paper, we present a construction that we call lifting, which allows predicates to be fully shared between the two components of a dl-program in a systematic way, and show how lifting can be used to provide intuitive solutions to a number of everyday reasoning problems involving the verification of integrity constraints and the implementation of default rules. This construction preserves consistency of the underlying knowledge base and complexity of the overall system. Furthermore, the resulting semantics of default rules has a natural interpretation under the original Reiter semantics.
- Congu, Checking Java Classes Against Property-Driven Algebraic SpecificationsPublication . Abreu, João; Caldeira, Alexandre; Lopes, Antónia; Nunes, Isabel; Reis, Luís S.; Vasconcelos, Vasco T.Congu is a tool that supports the checking of Java classes against property-driven algebraic specifications. This document presents the specification, languages, the tool usage, and its implementation, version 1.32. Chapter 1 describes the two specification languages: the language of abstract data types specifications, and that for defining refinement mappings between these specifications and Java classes. Chapter 2 explains how to install and use Congu tool. And finally, Chapter 3 presents the implementation details of the tool
- Design by Contract Using Meta-AssertionsPublication . Nunes, IsabelThe important role that class contracts - pre and post-conditions of methods, and invariants - play in the specification, monitoring and reuse of classes is becoming increasingly accepted by the OO community. The several languages of assertions and monitoring code generation tools that exist allow the specification and, eventually, the runtime checking of very powerful and elegant contracts. This is definitely so for classes as simple as Stack, Point or Account. However, when the aim is the writing of pre and post-conditions for methods in classes that are clients of those simple classes, the task reveals itself harder and brings undesirable effects, like the increasing in class coupling and encapsulation decreasing. In addition, the conviction that assertions should have no side effects in order to be possible to monitor them, weakens the expressive power of assertion languages and makes it more difficult to avoid the above mentioned undesirable effects. In this paper we propose a pattern to the design of class contracts that is an adaptation of existing patterns of design into a declarative context - the world of assertions. The use of this pattern produces 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 formally define their syntax and semantics. In order to be possible to check contracts at runtime, we define rules for the expansion of meta-assertions that can be monitored by existing tools, and we show grammatical and semantic soundness of the expansion
- A fault-location technique for Java implementations of algebraic specificationsPublication . Luis, Filipe; Nunes, IsabelExecuting comprehensive test suits allows programmers to strengthen the confidence on their software systems. However, given some failed test cases, finding the faults' locations is one of the most expensive and time consuming tasks, thereby any technique that makes it easier for the programmer to locate the faulty components is highly desirable. In this paper we focus on finding faults in object-oriented, more precisely Java, implementations of data types that are described by algebraic specifications. We capitalize on the ConGu and GenT approaches, namely on the models for the specification under study and the corresponding generated JUnit test suits that cover all axioms of the specification, and present a collection of techniques and underlying methodology, that give the programmer a means to find the location of a fault that causes the implementation to violate the specification. We propose Flasji, a stepwise process for finding the faulty method, which is transparent to the programmer, that applies the proposed techniques to find a collection of initial suspect candidates and to subsequently decide the prime suspect among them. We carried out an experiment to evaluate Flasji and obtained very encouraging results.
- Information Flow within Relational Multi-context SystemsPublication . Gaspar, Graça; Nunes, Isabel; Cruz-Filipe, LuísMulti-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.
- Patterns for Programming in the Semantic WebPublication . Gaspar, Graça; Cruz-Filipe, Luis; Nunes, IsabelOriginally proposed in the mid-90s, design patterns for software development played a key role in object-oriented programming not only in increasing software quality, but also by giving a better understanding of the power and limitations of this paradigm. Since then, several authors have endorsed a similar task for other programming paradigms, in the hope of achieving similar benefits. In this paper we discuss design patterns for the Semantic Web, giving new insights on how existing programming frameworks can be used in a systematic way to design large-scale systems. The common denominator between these frameworks is the combination between different reasoning systems, namely description logics and logic programming. Therefore, we chose to work in a generalization of dl-programs that supports several (possibly different) description logics, expecting that our results will be easily adapted to other existing frameworks such as multi-context systems. This study also suggests new constructs to enforce legibility and internal structure of logic-based Semantic Web programs.
- Specifying and Monitoring Java ClassesPublication . Lopes, Antonia; Nunes, Isabel; Vasconcelos, Vasco T.These lecture notes describe an Abstract Data Type approach to the specification of data structures meant to be implemented and monitored in an object-oriented imperative language.
- Testing Implementations of Algebraic Specifications with Design-by-Contract ToolsPublication . Nunes, Isabel; Lopes, Antónia; Vasconcelos, Vasco T.; Abreu, João; Reis, Luís S.We present an approach for testing Java implementations of abstract data types (ADTs) against their specifications. The key idea is to reduce this problem to the run-time monitoring of contract annotated classes, which is supported today by several runtime assertion-checking tools. The approach comprises an ADT specification language that allows automatic generation of monitorable contracts and a refinement language that supports the specification of the details of object-oriented implementations of ADTs
- Viewing dl-programs as multi-context systemsPublication . Henriques, Rita; Nunes, Isabel; Cruz-Filipe, LuísThe 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 mechanisms, dl-programs and multi-context systems, which address different aspects of this combination, and include different, incomparable programming constructs. Despite this, we show that every dl-program can be transformed in a multi-context system in such a way that the different semantics for each paradigm are naturally related. As a consequence, many useful constructions developed within the framework of dl-programs may be automatically translated to equivalent constructions in the setting of multi-context systems.