scispace - formally typeset
Search or ask a question
Book ChapterDOI

An Overview of AspectJ

TL;DR: AspectJ provides support for modular implementation of a range of crosscutting concerns, and simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes.
Abstract: AspectJ? is a simple and practical aspect-oriented extension to Java?. With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program; pointcuts are collections of join points; advice are special method-like constructs that can be attached to pointcuts; and aspects are modular units of crosscutting implementation, comprising pointcuts, advice, and ordinary Java member declarations. AspectJ code is compiled into standard Java bytecode. Simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes. Several examples show that AspectJ is powerful, and that programs written using it are easy to understand.

Content maybe subject to copyright    Report

Citations
More filters
Proceedings ArticleDOI
01 Sep 2001
TL;DR: This tutorial shows how to use AOP to implement crosscutting conerns in a concise modular way and includes a description of their underlying model, in terms of which a wide range of AOP languages can be understood.
Abstract: Aspect-oriented programming (AOP) is a technique for improving separation of concerns in software design and implementation. AOP works by providing explicit mechanisms for capturing the structure of crosscutting concerns. This tutorial shows how to use AOP to implement crosscutting conerns in a concise modular way. It works with AspectJ, a seamless aspect-oriented extension to the Java(tm) programming language, and with AspectC, an aspect-oriented extension to C in the style of AspectJ. It also includes a description of their underlying model, in terms of which a wide range of AOP languages can be understood.

3,187 citations

Proceedings ArticleDOI
23 May 2007
TL;DR: Model-Driven Engineering (MDE) is typically used to describe software development approaches in which abstract models of software systems are created and systematically transformed to concrete implementations as discussed by the authors, but full realizations of the MDE vision may not be possible in the near to medium-term primarily because of the wicked problems involved.
Abstract: The term model-driven engineering (MDE) is typically used to describe software development approaches in which abstract models of software systems are created and systematically transformed to concrete implementations. In this paper we give an overview of current research in MDE and discuss some of the major challenges that must be tackled in order to realize the MDE vision of software development. We argue that full realizations of the MDE vision may not be possible in the near to medium-term primarily because of the wicked problems involved. On the other hand, attempting to realize the vision will provide insights that can be used to significantly reduce the gap between evolving software complexity and the technologies used to manage complexity.

1,155 citations

Book
01 Jan 2004
TL;DR: The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories, which promises greater gains in productivity and predictability than those produced by incremental improvements to the current paradigm of object orientation.
Abstract: The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories. This approach promises greater gains in productivity and predictability than those produced by incremental improvements to the current paradigm of object orientation, which have not kept pace with innovation in platform technology. Software factories promise to make application assembly more cost effective through systematic reuse, enabling the formation of supply chains and opening the door to mass customization.

784 citations

Journal ArticleDOI
TL;DR: The paper describes JULIA, a Java implementation of the FRACTAL model, a small but efficient runtime framework, which relies on a combination of interceptors and mixins for the programming of reflective features of components.
Abstract: This paper presents FRACTAL, a hierarchical and reflective component model with sharing. Components in this model can be endowed with arbitrary reflective capabilities, from plain black-box objects to components that allow a fine-grained manipulation of their internal structure. The paper describes JULIA, a Java implementation of the model, a small but efficient runtime framework, which relies on a combination of interceptors and mixins for the programming of reflective features of components. The paper presents a qualitative and quantitative evaluation of this implementation, showing that component-based programming in FRACTAL can be made very efficient. Copyright © 2006 John Wiley & Sons, Ltd.

612 citations

Proceedings ArticleDOI
06 Nov 2005
TL;DR: A new perspective on software architecture is presented, which views software architecture as a composition of a set of explicit design decisions, which makes architectural design decisions an explicit part of a software architecture.
Abstract: Software architectures have high costs for change, are complex, and erode during evolution We believe these problems are partially due to knowledge vaporization Currently, almost all the knowledge and information about the design decisions the architecture is based on are implicitly embedded in the architecture, but lack a first-class representation Consequently, knowledge about these design decisions disappears into the architecture, which leads to the aforementioned problems In this paper, a new perspective on software architecture is presented, which views software architecture as a composition of a set of explicit design decisions This perspective makes architectural design decisions an explicit part of a software architecture Consequently, knowledge vaporization is reduced, thereby alleviating some of the fundamental problems of software architecture

605 citations


Cites methods from "An Overview of AspectJ"

  • ...AOP[13] with its implementations like AspectJ[12] and genVoca [5] are approaches using different techniques to achieve multiple separation of concerns....

    [...]

References
More filters
Book
Bjarne Stroustrup1
01 Jan 1985
TL;DR: Bjarne Stroustrup makes C even more accessible to those new to the language, while adding advanced information and techniques that even expert C programmers will find invaluable.
Abstract: From the Publisher: Written by Bjarne Stroustrup, the creator of C, this is the world's most trusted and widely read book on C. For this special hardcover edition, two new appendixes on locales and standard library exception safety have been added. The result is complete, authoritative coverage of the C language, its standard library, and key design techniques. Based on the ANSI/ISO C standard, The C Programming Language provides current and comprehensive coverage of all C language features and standard library components. For example: abstract classes as interfaces class hierarchies for object-oriented programming templates as the basis for type-safe generic software exceptions for regular error handling namespaces for modularity in large-scale software run-time type identification for loosely coupled systems the C subset of C for C compatibility and system-level work standard containers and algorithms standard strings, I/O streams, and numerics C compatibility, internationalization, and exception safety Bjarne Stroustrup makes C even more accessible to those new to the language, while adding advanced information and techniques that even expert C programmers will find invaluable.

6,795 citations


"An Overview of AspectJ" refers background in this paper

  • ...Flavors [35], New Flavors [37], CommonLoops [16] and CLOS [34] all support multiple-inheritance, declarative method combination and open classes....

    [...]

  • ...C++ supports multiple inheritance [35]....

    [...]

Journal ArticleDOI
Gregor Kiczales1
TL;DR: This work proposes to use aspect-orientation to automate the calculation of statistics for database optimization and shows how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries.
Abstract: The performance of relational database applications often suffers. The reason is that query optimizers require accurate statistics about data in the database in order to provide optimal query execution plans. Unfortunately, the computation of these statistics must be initiated explicitly (e.g., within application code), and computing statistics takes some time. Moreover, it is not easy to decide when to update statistics of what tables in an application. A well-engineered solution requires adding source code usually in many places of an application. The issue of updating the statistics for database optimization is a crosscutting concern. Thus we propose to use aspect-orientation to automate the calculation. We show how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries. Due to the automatic nature, computation takes place on time for complex queries, only when necessary, and only for stale tables. The implementation language for the automated aspect-oriented statistics update concern is AspectJ, a well known and mature aspect-oriented programming language. The approach can however be implemented in any other aspect-oriented language. Unlike in traditional object-oriented pattern solutions, e.g. using the interceptor pattern, we do not have to modify existing code.

5,161 citations

Journal ArticleDOI
TL;DR: In this paper, the authors discuss modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time, and the effectiveness of modularization is dependent upon the criteria used in dividing the system into modules.
Abstract: This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a “modularization” is dependent upon the criteria used in dividing the system into modules. A system design problem is presented and both a conventional and unconventional decomposition are described. It is shown that the unconventional decompositions have distinct advantages for the goals outlined. The criteria used in arriving at the decompositions are discussed. The unconventional decomposition, if implemented with the conventional assumption that a module consists of one or more subroutines, will be less efficient in most cases. An alternative approach to implementation which does not have this effect is sketched.

5,028 citations

Book
Adele E. Goldberg1, David Robson1
01 Jan 1983
TL;DR: This book is the first detailed account of the Smalltalk-80 system and is divided into four major parts: an overview of the concepts and syntax of the programming language, a specification of the system's functionality, and an example of the design and implementation of a moderate-size application.
Abstract: From the Preface (See Front Matter for full Preface) Advances in the design and production of computer hardware have brought many more people into direct contact with computers. Similar advances in the design and production of computer software are required in order that this increased contact be as rewarding as possible. The Smalltalk-80 system is a result of a decade of research into creating computer software that is appropriate for producing highly functional and interactive contact with personal computer systems. This book is the first detailed account of the Smalltalk-80 system. It is divided into four major parts: Part One -- an overview of the concepts and syntax of the programming language. Part Two -- an annotated and illustrated specification of the system's functionality. Part Three -- an example of the design and implementation of a moderate-size application. Part Four -- a specification of the Smalltalk-80 virtual machine.

3,882 citations


"An Overview of AspectJ" refers background in this paper

  • ...Subject-oriented programming is a means for composing and integrating disparate class hierarchies (subjects), each of which might represent different concerns [9]....

    [...]

Journal ArticleDOI
TL;DR: As I talked with enthusiasts and examined the systems they used, I began to develop a model of the features that produced such delight, and the central ideas seemed to be visibility of the object of interest; rapid, reversible, incremental actions; and replacement of complex command language syntax by direct manipulation of the objects of interest.
Abstract: These feelings are not, of course, universal, but the amalgam does convey an image of the truly pleased user. As I talked with these enthusiasts and examined the systems they used, I began to develop a model of the features that produced such delight. The central ideas seemed to be visibility of the object of interest; rapid, reversible, incremental actions; and replacement of complex command language syntax by direct manipulation of the object of interest-hence the term \"direct manipulation.\" Examples of direct manipulation systems

2,012 citations


"An Overview of AspectJ" refers methods in this paper

  • ...In AspectJ, classes and aspects are modular units, even if an aspect can crosscut classes.7 7 Flavors, New Flavors and CLOS use the Common Lisp module system, called the package system....

    [...]

  • ...This advice framework is based on the declarative method combination mechanism in CLOS [11] (which itself was modeled on the demon methods of Flavors [8, 10, 31])....

    [...]

  • ...Flavors [35], New Flavors [37], CommonLoops [16] and CLOS [34] all support multiple-inheritance, declarative method combination and open classes....

    [...]