A Model-driven Pointcut Language for More Robust Pointcuts (original) (raw)

Application-specific models and pointcuts using a logic metalanguage

Computer Languages, Systems & Structures, 2008

In contemporary aspect-oriented languages, pointcuts are usually specified directly in terms of the structure of the source code. The definition of such low-level pointcuts requires aspect developers to have a profound understanding of the entire application's implementation and often leads to complex, fragile, and hard to maintain pointcut definitions. To resolve these issues, we present an aspect-oriented programming system that features a logic-based pointcut language that is open such that it can be extended with application-specific pointcut predicates. These predicates define an application-specific model that serves as a contract that base-program developers provide and aspect developers can depend upon. As a result, pointcuts can be specified in terms of this more high-level model of the application which confines all intricate implementation details that are otherwise exposed in the pointcut definitions themselves.

Transformational Derivation of Programs Using the Focus System

ACM Sigsoft Software Engineering Notes, 1988

Trunsfomationul del.ivation, formal derivation of programs using the paradigm of program transformation, has been known for several years 341. But, its practical use in program development is still elusive. Hand derivation of any significant program is fraught with long sequences of low-level formal manipulations which are tedious and error-prone. The pravticality of the program derivation method thus depends on automated support for such manipulations. We are constructing a program derivation support system called Focus, designed along the following guiding principles: 0 The system must be interactive. It should let the user make the program design decisions and handle the formal details. 0 The interaction with the system must be at a sufficiently high-level. 0 The system must be flezible. It should not impose an overly restrictive discipline on the user regarding how programs should be derived. 0 The automation of the formal details must be in such a way that the behavior of the system can be easily predicted and understood. 0 The seuwh spaces involved in the automated transformation operations must be reasonably s m a l l , so that the system does not produce a large number of choices as a result of any operation. 'This paper is to appear in the Proceeding of Third Symposium on Software Development Environments, ACM, 1988. T h i s research was supported in part by NASA grant NAG1-613. /'( j --(NASA -CB-1 8 48 7 5 ) DERIVATION OF PBOGRAHS U S I N G THE FOCUS SYSTEH ( I l l i n o i s Univ.) 2 2 p CSCL 698 T R A NS FORH AT I O N AL N 89-24802 Unclas G3/61 0199000 0

Change-oriented software engineering

2007

In aspect-oriented programming, pointcuts are formulated as conditions over the context of dynamic events in the execution of a program. Hybrid pointcut languages also allow this context to come from interactions between the pointcut language and the base program. While some pointcut languages only allow conditions on the current execution event, more recent proposals have demonstrated the need for expressing conditions over a history of join points. Such pointcut languages require means to balance the expressiveness of the language with the additional memory and runtime overhead caused by keeping a history of join point context data. In this paper, we introduce a logic-based pointcut language that allows interaction with the base program as well as pointcuts over a history of join points. We introduce forward chaining as an implementation model for this language, and discuss possible optimization strategies for the additional overhead. 1 1 ACM, 2007. This is a minor revision of the work published in

Unifying program construction and modification

Logic Journal of IGPL, 1998

We propose a method which integrates program modification to the refinement calculus style of program development. Given a program developed through stepwise refinement of a specification, we propose an approach to specify modifications and to derive a new program from the existing refinement steps. This approach is based on the refinement lattice operator meet. A modification to a specification is represented by taking the meet of the old specification and the new feature to add. A solution to the new specification is constructed by coercing the new feature to match the structure of the existing refinement steps. The method fosters reuse of refinement steps and their proofs. We also show that program construction is streamlined by using coercion 1 .

A classification system and analysis for aspect-oriented programs

ACM SIGSOFT Software Engineering Notes, 2004

We present a new classification system for aspect-oriented programs. This system characterizes the interactions between aspects and methods and identifies classes of interactions that enable modular reasoning about the crosscut program. We argue that this system can help developers structure their understanding of aspect-oriented programs and promotes their ability to reason productively about the consequences of crosscutting a program with a given aspect.

Aspect-oriented programming: The fun has just begun

Software Design and Productivity Coordinating Group– …, 2001

We are on the verge of a fundamental change in software development. A central idea in all science and engineering-the idea of working with a system through multiple perspectives or views-is being enabled in software development in a powerful new way. In the past, software developers have had good technology for programming at different levels of abstraction or, in other words, working with views at different levels of detail. But more recently we have learned how to program through different crosscutting views. The immediate impact of this change has been to make it possible to modularize aspects of a system's implementation that previously could not be modularized. This is leading to software that is significantly more flexible, adaptable, and in all likelihood more robust than what we could previously develop. But the fun has just begun. Within the framework of current AOP proposals we can see significant room for further improvement and power. Experience with AOP is leading developers and researchers to ask for and develop exciting new features. But we can also see signs of a next generation of AOP technology, that we call fluid AOP. Fluid AOP involves the ability to temporarily shift a program (or other software model) to a different structure to do some piece of work with it, and then shift it back. This is analogous to electrical engineers using the Four ier transform to make certain problems easier to solve. We believe that the combination of traditional static structuring mechanisms like OOP, with static AOP mechanisms that support crosscutting, and fluid AOP mechanisms will enable a fundamentally more solid engineering foundation for software development than we have had to date. This is because developers will have the ability to work with programs more like other disciplines work with models. Developers will be able to write programs at greater or le sser levels of detail, and write programs that crosscut, and be able to fluidly restructure programs for particular purposes. We believe that this kind of technical foundation for software engineering is at least as important as the processanalogy foundations that have received so much attention. In fact, we believe these technical foundations may make it possible to better integrate process and technical issues.

Improve pointcut definitions with program views

Proceedings of the 5th workshop on Engineering properties of languages and aspect technologies - SPLAT '07, 2007

Aspect-oriented programming languages select join points using pointcut constructs that depend on the syntactic structure of the base program. As the base program evolves, the pointcuts may no longer capture the intended set of join points. Also, pointcuts may select join points so that aspects can observe program behavior protected by encapsulation and this makes local reasoning difficult.

Design-based pointcuts robustness against software evolution

RAM-SE'06–ECOOP'06 Workshop on Reflection, …

At the moment, aspects are not robust against evolutions in the base program. This is because pointcut definitions typically rely heavily on the structure of the base pro-gram. This tight coupling of the pointcut definitions to the base program's structure can seriously hinder the ...

Utilizing Design Information in Aspect-Oriented Programming

2005

Traditionally in aspect-oriented languages, pointcut designators select joinpoints of a program based on lexical information such as explicit names of program elements. However, this reduces the adaptability of software, since it involves too much information that is hard-coded, and often implementationspecific. We claim that this problem can be reduced by referring to program units through their design intentions. Design intention is represented by annotated design information, which describes for example the behavior of a program element or its intended meaning. In this paper, we analyze four techniques that are regularly used in state-of-the-art object-oriented languages in associating design information with program elements. Also, the usage of design information in the weaving process of aspect-oriented languages is illustrated and their deficiencies are outlined. Accordingly, we formulate requirements for the proper application of design information in aspect-oriented programming. We discuss how to use design information for the superimposition of aspects, and how to apply superimposition to bind design information to program elements. To achieve this, we propose language abstractions that support semantic composition: the ability to compose aspects with the elements of the base program that incorporate certain design information. Based on this proposal, we show how the aspect-oriented language Compose* can be extended to support design information. We demonstrate the application of design information to improve the reusability of aspects. The paper ends with related works, a discussion, and conclusions.

Formal Methods to Aid the Evolution of Software

International Journal of Software Engineering and Knowledge Engineering, 1995

There is a vast collection of operational software systems which are vitally important to their users, yet are becoming increasingly difficult to maintain, enhance, and keep up to date with rapidly changing requirements. For many of these so-called legacy systems, the option of throwing the system away and rewriting it from scratch is not economically viable. Methods are therefore urgently required which enable these systems to evolve in a controlled manner. The approach described in this paper uses formal proven program transformations, which preserve or refine the semantics of a program while changing its form. These transformations are applied to restructure and simplify the legacy systems and to extract higher-level representations. By using an appropriate sequence of transformations, the extracted representation is guaranteed to be equivalent to the code. The method is based on a formal wide spectrum language, called WSL, with an accompanying formal method. Over the last ten ye...