In this paper, we show how automated support can be provided for identifying refactoring opportunities, e.g., when an application's design should be refactored and which refactoring (s) in particular should be applied. Such support is achieved by using the technique of logic meta programming to detect so-called bad smells and by defining a framework that uses this information to propose adequate refactorings. We report on some initial but promising experiments that were applied using the proposed techniques.

In this paper, we show how elaborate support for framework-based software evolution can be provided based on explicit documentation of the hot spots of object-oriented application frameworks. Such support includes high-level transformations that guide a developer when instantiating applications from a framework by propagating the necessary changes, as well as application upgrading facilities based on these transformations. The approach relies on active declarative documentation of the design and evolution of the framework's hot spots, by means of metapatterns and their associated transformations.

The goal of aspect-oriented programming is to modularize crosscutting concerns (or aspects) at the code level. These aspects can be defined in either a general-purpose language or in a language that is fine-tuned to a specific aspect in consideration. Aspect-specific languages provide more concise and more readable aspect declarations but are limited to a specific domain. Moreover, multiple aspects may be needed in a single application and combining aspects written in different aspect languages is not an easy task.

Software often needs to be modified for accommodating requirements changes through the software life cycle. To deal with several accidental requirements changes related to software maintenance, a systematic and safe approach to modifying softwares is needed. The design patterns provide a high degree of design flexibility for such accidental requirements changes. In this paper, we propose an automated approach to refactoring based on design patterns in Java programs. In our approach, for a particular design pattern, we define an inference rule to automatically identify a set of candidate spots and a refactoring strategy to transform one of the set of candidate spots into the desired design pattern structure. A candidate spot may be a class or a set of classes to which the design patterns can be applied. We believe that our approach would be helpful to the maintainers in the sense that much of manual analysis on source code can be reduced, and the fashion of automated program transformation preserves the behavior of the original program by means of the refactoring technique.

Reflective systems have a causally connected (metalevel) representation of themselves. Most reflective systems use the same language to reason about their metalevel representation as the language that is used to reason about their domain. In symbiotic reflection a di#erent language is used at the metalevel. The practical usability of this symbiotic reflection is enhanced if a linguistic symbiosis is accomplished that transparantly integrates both languages. Implementing such a linguistic symbiosis is relatively straightforward if the meta language and the base language share the same programming paradigm. The problem becomes far more complex when the paradigms di#er. This paper describes the extension of the symbiotic reflective system SOUL with a linguistic symbiosis between a logic meta language and an object-oriented base language.

It is a well-known problem that design information of object-oriented programs is often lost or is not kept up-to-date when the program evolves. This design information can be recovered from the program using such techniques as logic meta programming. In this technique logic queries are used to check whether the program is implemented along certain well-known patterns. Currently the technique relies on structural information and patterns are expressed in the queries as conditions over structural elements of the program. Some patterns are however better expressed in dynamic terms which requires behavioural information about the program. Such information can be obtained from execution traces of the program, but these record only one possible input dependent program execution out of many. Abstract interpretation of the object-oriented program could provide a well-founded means for extracting the necessary behavioural information. Key words: logic meta programming, design recovery, dynamic analysis, abstract interpretation 1

The quality of an application’s implementation can be assured by validating the presence or absence of a set of userprescribed software patterns such as software engineering best practices, programming conventions and indications of poor programming. Existing pattern detection techniques, however, interpret pattern descriptions in an inflexible manner, leaving the quality assurance tool to approve only the most strictly adhering pattern implementations. In order to detect various concrete pattern implementations using a single pattern description, we have combined logic meta programming —wherein patterns can be expressed as constraints over facts representing a program’s source code—, fuzzy logic and static program analysis in a way that is completely transparant to the end-user. We have achieved this by having the conditions in a logic rule interpreted as constraints over the run-time behavior source code constructs give rise to instead of as constraints over the literal source description often suffices to recognize various concrete implementation variants with an indication of the similarity pattern description.

In the Eclipse JDT, the Java reference resolution rules are applied as fully as possible, thereby either determining the unique target for a given reference or signalling that the reference cannot be resolved. However, a variety of development tasks require the manipulation of code for which incomplete resolution of references is both possible and useful. This paper motivates the need for incomplete resolution during a software reuse-and-integration task and the difficulties that result. A proof-of-concept implementation is described that is used as a basis for reuse tool support and that can be used for other transformation tools. 1.

he first part of the presentation we show how the environment and associated tools can be used in practice to: - Reason about object-oriented programs (including naming and programming conventions [MMW 2001], design pattern extraction [W 1998], type inferencing, UML model extraction, architectural views [MW 1999], ...) - Declaratively generate code (including source code templates, aspect-oriented programming, design pattern code generation [MT 2001], ...) - Support software evolution (including refactoring, software merging [MT 2001], ...) During the second part of the presentation, we take a closer look at the technical details. We show how high-level software artifacts can be expressed in terms of logic facts and rules. For this, we require that the logic meta programming language lives in symbiosis with the object-oriented base language, allowing base level programs to be manipulated as terms, facts or rules in the meta level. In the case of Smalltalk, we use the reflection fac

In this paper, we show how elaborate support for framework-based software development can be provided based on explicit documentation of the hot spots of object-oriented application frameworks. This support ranges from automatically verifying whether appropriate design constraints are preserved, over providing highlevel transformations that guide a developer when instantiating applications from a framework, to supporting software upgrades based on these transformations. The hot spots are documented by means of design patterns, and we use metapatterns as an abstraction to define the associated design constraints and high-level transformations. 1