Carlos Noguera

SPOON: A library for implementing analyses and transformations of Java source code

This paper presents SPOON, a library for the analysis and transformation of Java source code. SPOON enables Java developers to write a large range of domain‐specific analyses and transformations in an easy and concise manner. SPOON analyses and transformations are written in plain Java. With SPOON, developers do not need to dive into parsing, to hack a compiler infrastructure, or to master a new formalism. Copyright

Annotation Framework Validation Using Domain Models

Frameworks and libraries that use annotations are becoming popular. However, there is not enough software engineering support for annotation development. In particular, the validation of constraints in the use of annotations requires further support. In this paper we postulate that annotation frameworks are a projection of the domain model into a programming language model. Using this idea, we have developed a tool that allows the annotation programmer to specify, and then validate the constraints of the annotation framework regarding a given annotated application using a domain model. To validate our approach to the validation of constraints using models, we apply it to the Fraclet annotation framework and compare it to the previous implementation.

Behavioral similarity matching using concrete source code templates in logic queries

Program query languages and pattern-detection techniques are an essential part of program analysis and manipulation systems. Queries and patterns permit the identification of the parts of interest in a programs implementation through a representation dedicated to the intent of the system (e.g. call-graphs to detect behavioral flaws, abstract syntax trees for transformations, concrete source code to verify programming conventions, etc). This requires that developers understand and manage all the different representations and techniques in order to detect various patterns of interest. To alleviate this overhead, we present a logic-based language that allows the programs implementation to be queried using concrete source code templates. The queries are matched against a combination of structural and behavioral program representations, including call-graphs, points-to analysis results and abstract syntax trees. The result of our approach is that developers can detect patterns in the queried program using source code excerpts (embedded in logic queries) which act as prototypical samples of the structure and behavior they intend to match.

AVal: an Extensible Attribute-Oriented Programming Validator for Java

Attribute-oriented programming (@OP) permits programmers to extend the semantics of a base program by annotating it with attributes defined in an attribute domain-specific language (AttDSL). In this article, we propose AVal: a Java5 framework for the definition and checking of rules for @OP in Java. We define a set of meta-annotations to allow the validation of @OP programs, as well as the means to extend these meta-annotations by using a compile-time model of the programs source code. AVal is fully integrated into the Eclipse IDE. We show the usefulness of the approach by using examples of its use applied to three AttDSLs: an @OP framework that helps programming Simple API for XML parsers, an @OP extension for the Fractal component model called Fraclet, and the JSR 181 for web services definition. Copyright

Co-evolving Annotations and Source Code through Smart Annotations

Annotations are a means to attach additional meta data to the source code of a system. Nowadays, more and more technologies rely on the presence of such annotations in the source code: beyond their use for documentation purposes, annotations impact the behaviour of the system. Since there exists little or no support to make sure that upon evolution of the system, the source code remains correctly annotated, source code can become miss-annotated. This in turn, can result in erroneous behaviour. In this paper we present Smart Annotations, an approach for co-evolving source code and annotations. Our approach enables developers to constrain the use of annotations in the source code and offers tool support to identify conflicts between source code and annotations. To illustrate the use of our approach, we demonstrate its applicability using examples from the domain of aspect-oriented programming and Enterprise Java Beans.

A History Querying Tool and Its Application to Detect Multi-version Refactorings

Version Control Systems (VCS) have become indispensable in developing software. In order to provide support for change management, they track the history of software projects. Tool builders can exploit this latent historical information to provide insights in the evolution of the project. For example, the information needed to identify when and where a particular refactoring was applied is implicitly present in the VCS. However, tool support for eliciting this information is lacking. So far, no general-purpose history querying tool capable of answering a wide variety of questions about the evolution of software exists. Therefore, we generalize the idea of a program querying tool to a history querying tool. A program querying tool reifies the programs code into a knowledge base, from which it retrieves elements that exhibit characteristics specified through a user-provided program query. Our history querying tool, QwalKeko, enables specifying the evolution of source code characteristics across multiple versions of Java projects versioned in Git. We apply QwalKeko to the problem of detecting refactorings, specified as the code changes induced by each refactoring. These specifications stem from the literature, but are limited to changes between two successive versions. We demonstrate the expressiveness of our tool by generalizing the specifications such that refactorings can span multiple versions.

REME-D: a reflective epidemic message-oriented debugger for ambient-oriented applications

Debuggers are an integral part, albeit often neglected, of the development of distributed applications. Ambient-oriented programming (AmOP) is a distributed paradigm for applications running on mobile ad hoc networks. In AmOP the complexity of programming in a distributed setting is married with the network fragility and open topology of mobile applications. To our knowledge, there is no comprehensive debugging approach that tackles both these issues. In this paper we present REME-D, an online debugger that integrates techniques from distributed debugging (event-based debugging, message breakpoints) and proposes facilities to deal with ad hoc, fragile networks -- epidemic debugging, and support for frequent disconnections. A prototype for REME-D is implemented for the AmbientTalk language using the meta-actor protocol provided by AmbientTalk to implement its features.

Propagating Decisions to Detect and Explain Conflicts in a Multi-step Configuration Process

In configuration processes with multiple stakeholders, conflicts are very likely because each decision maker has a different concerns and expectations about the product. They may not be aware of features selected by others or the restrictions that these selections impose. To help solve the conflicts, this paper introduces a new approach to provide explanations about their causes. Our approach is based on representing features from different concerns using different Feature Models (FMs), and relating them through Feature-Solution Graphs. An FSG contains dependency relationships between two FMs: one feature from the left side forces or prohibits the selection of features in the right side feature model. The strategy to detect and explain conflicts is based on propagation of constraints over the FSGs. We claim that our approach is more expressive and efficient than when using a single FM that contains all concerns and SAT solvers to detect conflicts.

Detecting function purity in JavaScript

We present an approach to detect function purity in JavaScript. A function is pure if none of its applications cause observable side-effects. The approach is based on a pushdown flow analysis that besides traditional control and value flow also keeps track of write effects. To increase the precision of our purity analysis, we combine it with an intraprocedural analysis to determine freshness of variables and object references. We formalize the core aspects of our analysis, and discuss our implementation used to analyze several common JavaScript benchmarks. Experiments show that our technique is capable of detecting function purity, even in the presence of higher-order functions, dynamic property expressions, and prototypal inheritance.

Distributed debugging for mobile networks

Debuggers are an integral part, albeit often neglected, of the development of distributed applications. Ambient-oriented programming (AmOP) is a distributed paradigm for applications running on mobile ad hoc networks. In AmOP the complexity of programming in a distributed setting is married with the network fragility and open topology of mobile applications. To our knowledge, there is no debugging approach that tackles both these issues. In this paper we argue that a novel kind of distributed debugger that we term an ambient-oriented debugger, is required. We present REME-D (read as remedy), an online ambient-oriented debugger that integrates techniques from distributed debugging (event-based debugging, message breakpoints) and proposes facilities to deal with ad hoc, fragile networks - epidemic debugging, and support for frequent disconnections.