Eduardo Kessler Piveta

Searching for Opportunities of Refactoring Sequences: Reducing the Search Space

During software development and evolution activities, the developers focus the refactoring efforts on choosing and applying refactoring patterns (or sequences of patterns) that are likely to improve the software quality. Considering the search for opportunities of refactoring sequences,the main problem is the size of the search space (there are too many possible sequences to be evaluated). We propose an approach to narrow the number of refactoring sequences by discarding those that semantically does not make sense and avoiding those that lead to the same results. We provide a detailed example of the approach considering sequences for method manipulation, showing how the number of sequences can be significantly reduced.

An empirical study of aspect-oriented metrics

Metrics for aspect-oriented software have been proposed and used to investigate the benefits and the disadvantages of crosscutting concerns modularisation. Some of these metrics have not been rigorously defined nor analytically evaluated. Also, there are few empirical data showing typical values of these metrics in aspect-oriented software. In this paper, we provide rigorous definitions, usage guidelines, analytical evaluation, and empirical data from ten open source projects, determining the value of six metrics for aspect-oriented software (lines of code, weighted operations in module, depth of inheritance tree, number of children, crosscutting degree of an aspect, and coupling on advice execution). We discuss how each of these metrics can be used to identify shortcomings in existing aspect-oriented software.

Mapping OWL ontologies to relational schemas

Many applications require storing XML data, which can be achieved by using a relational database (RDB). In order to accomplish that, we need a set of transformation rules that maps the XML structure to a collection of relations. However, XML files from the same application domain might have different structures, making the mapping process to a unique relational schema more difficult. To overcome this, we can previously generate an integrated schema that represents the individual XML structures, and then map it to the relational format. Afterwards, the original XML files are stored into the database. In our proposal, the integrated schema is represented as an ontology. In this paper, we propose a mechanism for generating the relational schema from a set of integrated XML files, which includes defining a set of mapping rules from the OWL (Ontology Web Language) ontology to the relational format. The mapping process is implemented in OntoRel tool.

The AOSD Research Community in Brazil and Its Crosscutting Impact

In this paper, we present the birth, growth, and maturation of Aspect-Oriented Software Development (AOSD) research over the last years, with emphasis on the Brazilian AOSD community and its research contributions. These research contributions are illustrated from different perspectives: (i) an overview of the research work developed by our community in several prominent software engineering areas; (ii) a historical chronology of the community; and (iii) the growth, impact and quality of research outcomes.

A Double Effect λ-calculus for Quantum Computation

In this paper we present a double effect version of the simply typed λ-calculus where we can represent both pure and impure quantum computations. The double effect calculus comprises a quantum arrow layer defined over a quantum monadic layer. In previous works we have developed the quantum arrow calculus, a calculus where we can consider just impure (or mixed) quantum computations. Technically, here we extend the quantum arrow calculus with a construct (and equations) that allows the communication of the monadic layer with the arrow layer of the calculus. That is, the quantum arrow is defined over a monadic instance enabling to consider pure and impure quantum computations in the same framework. As a practical contribution, the calculus allows to express quantum algorithms including reversible operations over pure states and measurements in the middle of the computation using a traditional style of functional programming and reasoning. We also define equations for algebraic reasoning of computations involving measurements.

Representing refactoring opportunities

Approaches for the representation of refactoring opportunities and their association with refactorings are usually described in an informal basis. This informality can hamper the creation of catalogues and tools to represent and search for refactoring opportunities. We propose an unified way to represent both the conditions in which the application of a refactoring can be advantageous and the mechanisms to associate these conditions with refactorings. The resulting representation mechanisms can be used to express search criteria based on software metrics, structural problems, heuristics or improvements on the software quality.

FJQuantum - A Quantum Object Oriented Language

Several languages and libraries has been proposed to work with quantum programs, usually considering the imperative and functional paradigms. In this paper, we discuss the application of the FJQuantum language, an object-oriented language based on Featherweight Java to develop programs that handle quantum data and operations.

Typed context awareness Ambient Calculus for pervasive applications

The idea of pervasive computing is that information processing will become part of everyday life, and will be available everywhere, making computing so natural to the point of being invisible in the ambient. An important concept that arises with pervasive computing is context awareness. Context is any information that can be used to characterize an entity. Based on contextual information, applications can dynamically adapt themselves to the environments in which they operate. The Calculus of Context-aware Ambients (CCA) is an untyped formal language used to describe mobile and context-aware pervasive applications. The CCA extends the Ambient Calculus by providing new features, such as context-guarded action and process abstraction, allowing to model contexts and context-aware computations. In this work, we define a type system for the CCA, called CCAT, with the focus in the communication between processes and in the correct use of process abstraction and contexts, extending previous works on the definition of type systems for mobile computing. Moreover, we prove that the proposed type system has the subject reduction property (or type preservation). We also model a hospital scenario using CCAT to demonstrate the use of the proposed type system.

Automated refactorings for high performance Fortran programmes

Refactoring is a software engineering technique aimed at improving the design of software applications, without changing their external behaviour. Several refactorings have been proposed for object-oriented languages, but there are few related works focusing on procedural programming. Fortran is a procedural language heavily used in high performance computing, which is not fully explored considering refactoring support. In this paper, we describe a set of automated refactorings for Fortran based on the Photran plug-in, which is integrated with the Eclipse integrated development environment (IDE). We present a set of experiments to evaluate the impact of the proposed refactorings in third-party Fortran applications. The results show that the proposed refactorings improve the design of existing applications without compromising their performance.

AsyncRFJ: an asynchronous approach to reactive object-oriented programming

While the object-orientation is the most used paradigm for developing general purpose software systems, the use of reactive systems has been growing lately. One of the differences between them is that while the first offers an imperative style, the latter focuses on a functional style. In this paper, we present the semantics for AsyncRFJ, an object-oriented language based on Featherweight Java, created to reason and to develop programs handling reactive data flow in the context of object-oriented programming. Additionally, we provide an interpreter for the proposed semantics and a set of examples designed to illustrate the language.