SUMMARYThis 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.

Program queries can answer important software engineering questions that range from "which expressions are cast to this type?" over "does my program attempt to read from a closed file?" to "does my code follow the prescribed design?". In this paper, we present a comprehensive tool suite for querying Java programs. It consists of the logic program query language SOUL, the CAVA library of predicates for quantifying over an Eclipse workspace and the Eclipse plugin BARISTA for launching queries and inspecting their results. BARISTA allows other Eclipse plugins to peruse program query results which is facilitated by the symbiosis of SOUL with Java -setting SOUL apart from other program query languages. This symbiosis enables the CAVA library to forego the predominant transcription to logic facts of the queried program. Instead, the library queries the actual AST nodes used by Eclipse itself, making it trivial for any Eclipse plugin to find the AST nodes that correspond to a query result. Moreover, such plugins do not have to worry about having queried stale program information. We illustrate the extensibility of our suite by implementing a tool for co-evolving source code and annotations using program queries.

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 program's 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 © 2007 John Wiley & Sons, Ltd.

Three patients receiving diphenylhydantoin (DPH) were seen with a reversible process suggesting mycosis fungoides. Clinical and laboratory manifestations included generalized pruritic exfoliative erythroderma, eosinophilia, lymphadenopathy, hepatosplenomegaly, circulating Sézary cells, epidermal Pautrier's microabscesses on skin biopsy, and moderate liver dysfunction. Studies of the distribution and function of the various lymphocyte subpopulations from these patients showed: (1) an increase in the relative and absolute number of T lymphocytes (85–92%); (2) significant stimulation of lymphocyte‐blastic transformation by DPH and low response to pokeweed mitogen stimultion; (3) the impaired ability of Tγ lymphocytes to suppress B‐cell differentiation and immunoglobulin production. With only one exception, 15 symptom‐free patients on DPH showed none of these abnormalities. The clinical manifestations and immunologic abnormalities of patients with this pseudo mycosis fungoides syndrome remitted three to four weeks after DPH administration was discontinued. The proliferation of T lymphocytes and the inhibition of the function of Tγ‐suppressor lymphocytes noted in these patients may be significant to the development of other types of pseudolymphoma and to that of true lymphoma.

Abstract-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.

No abstract

Abstract-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 program's 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.

Abstract. 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.