We propose to use a logic meta-system as a general framework for aspect-oriented programming. We illustrate our approach with the implementation of a simpli#ed version of the cool aspect language for expressing synchronization of Java programs. Using this case as an example we illustrate the principle of aspect-orientedlogic meta programming and how it is useful for implementing weavers on the one hand and on the other hand also allows users of aop to #ne-tune, extend and adapt an aspect language to their speci#c needs.

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.

Design patterns are a standard means to create large software systems. However, with standard object-oriented techniques, typical implementations of such patterns are not themselves reusable software entities. Evolution of a program into a ‘patterned ’ form (also known as ‘refactoring to patterns’) and subsequent evolution of a ‘patterned ’ design is largely left to the programmer. Due to their ability to encapsulate elements that crosscut different modules, aspect languages have the potential to change this situation. For many interesting patterns, a large part of the process of refactoring to patterns can already be implemented modularly in aspects. Still, existing aspect languages can only express a small number of typical patterns implementations in a generally reusable way. In many cases, evolution of an application that uses one pattern variant into one that uses another one cannot be achieved at all. In others, it requires duplicating parts of the aspect implementation, thus creating scattered code in the aspects and hindering their further evolution. In this paper, we argue that aspect languages need to provide genericity in order to support reusable pattern implementations. We sketch the main features of the generic aspect language LogicAJ, and show how it supports software evolution. In particular, we demonstrate how LogicAJ enables evolution of a non-patterned implementation to a patterned one and easy transition from one patterned implementation to another. 1.

Path logic programming is a modest extension of Prolog for the specification of program transformations. We give an informal introduction to this extension, and we show how it can be used in coding standard compiler optimisations, and also a number of obfuscating transformations. The object language is the Microsoft .NET intermediate language (IL).

Abstract. Aspect-oriented programming languages promise to provide better modularity than pure object-oriented decomposition. A typical benefit of increased modularity is ease of maintenance, evolution and reuse. However, it has been noted by various researchers that many of the first generation aspect languages do not provide the degree of reusability initially hoped for. In this paper, we argue that the problem is due to a lack of support for aspect genericity, respectively to a lack of support for a sufficiently powerful kind of genericity. We introduce the concept of uniform genericity for aspect languages and discuss in which ways it goes beyond previous approaches to generic aspects. Then we present LogicAJ, a uniformly generic aspect language. Using LogicAJ as an example, we show how uniform aspect genericity recommends itself for implementing reusable solutions of various problems discussed in literature, ranging from the generic replacement of object instantiation, over verification of constraints and conventions, to the generic implementation of design pattern variants. We believe uniform genericity to be an important ingredient for second generation aspect languages whose aspects are only loosely coupled to base programs, thus easing aspect reuse and independent evolution of aspects and base programs. 1

in my opinion, it

Certain features of the object-oriented paradigm are a serious impediment for the runtime performance of object-oriented programs.

Aspects avoid tangled solutions for cross-cutting design concerns. Unfortunately there are various reasons why it may be hard to use an aspect language or aspect composition framework as a solution, even though developers are faced with crosscutting design concerns or tangled code structures. For instance, certain limitations of specific aspect composition frameworks might hinder the use of aspects. Or because of particular project requirements, such as constraints for the programming language or limitations of performance and memory, developers are not able to use an existing aspect composition framework. In such cases, developers would benefit from better understanding existing aspect composition frameworks. This would help developers to customize existing techniques or implement (simple) aspect composition frameworks from scratch. For these purposes, we present a pattern language for tracing and manipulating software structures and dependencies, and then explain different, existing aspect composition frameworks as sequences through this pattern language. We also evaluate alternative designs, common design trade-offs, and design decisions for implementing aspect composition frameworks.

Logic meta-programming in Prolog is a powerful way to express program analysis and transformation. However, its use can be difficult and error-prone because it requires programmers to know the meta-level representation of the analysed language and to think and express their analyses in terms of this lowlevel representation. In addition, the backtracking-based evaluation strategy of Prolog may lead to subtle semantic problems when used to express transformations of a logic database. In this paper, we propose an alternative approach, GenTL, a generic transformation language that combines logic-based C onditional T ransformations (CTs) and concrete syntax patterns. This combination addresses the above problems while still offering the full expressive power of logic meta-programming. Compared to approaches based on other formalisms, the design of GenTL offers advantages in terms of composability and easy transformation interference analysis.

An obfuscation is a behaviour-preserving program transformation whose aim is to make a program “harder to understand”. Obfuscations are applied to make reverse engineering of a program more difficult. Two concerns about an obfuscation are whether it preserves behaviour (i.e. it is correct) and the degree to which it maintains efficiency. Obfuscations are applied mainly to objectoriented programs but constructing proofs of correctness for such obfuscations is a challenging task. It is desirable to have a workable definition of obfuscation which is more rigorous than the metric-based definition of Collberg et al. and overcomes the impossibility result of Barak et al. for their strong cryptographic definition. We present a fresh approach to obfuscation by obfuscating abstract datatypes allowing us to develop structure-dependent obfuscations that would otherwise (traditionally) not be available. We regard obfuscation as data refinement enabling us to produce equations for proving correctness and we model the datatype