2002 Proceeding- Conference Chair:
- Harold Ossher,
- Program Chair:
- Gregor Kiczales
Welcome to AOSD 2002, the first conference dedicated to the field of Aspect-Oriented Software Development. The conference provides a variety of events and activities of interest to researchers and practitioners in the academic, industrial and government communities alike.This is a particularly exciting time to be involved in the AOSD field. The fundamental goal of AOSD -----effective separation of concerns--- was enunciated about 30 years ago, most notably by Dijkstra and Parnas. They even identified some of the challenging requirements that AOSD researchers are addressing today, but it took until recently for technology to catch up and provide solu- tions. The first two decades or so of research on separation of concerns focused primarily on providing new kinds of modules, able to separate concerns in new ways. This led to some key advances, including abstract data types and object-oriented programming, which have had dramatic impact on software engineering research and practice. The approaches suffered from a limitation, how- ever: they could encapsulate concerns that aligned with the dominant decomposition of the software into modules such as objects or classes, but not concerns that cut across multiple modules. With a few earlier glimmerings, several flavors of technology that enable separation of crosscutting concerns began to emerge in the early 1990s. These technological breakthroughs finally enabled more ambitions separation-of-concerns goals to be addressed. The advent and promulgation of aspect-oriented programming awakened broader interest in the area, on the part of researchers and practitioners alike. There is now an active and growing community engaged in research and reduction to practice using a variety of different approaches and at various phases of the software lifecycle.The time is right for practitioners to begin using AOSD technology, for researchers to solve some of the challenging problems that remain, and for researchers and practioners to work together to make AOSD a mainstream software development technology. This conference is designed to further these goals by providing:• A forum for dissemination and discussion of leading-edge research and for researchers in the field to get together.• Opportunities for researchers and practitioners to come together to discuss issues of mutual interest, including how AOSD technologies can be used in practice and details of real technical problems that can motivate further research.• Discussion of the challenges faced when adopting AOSD in industry, and what can he done to address them.Refereed papers are a cornerstone of any conference. Fifty papers were submitted to the program committee. Every paper was read by at least three reviewers, except program committee member papers, which were read by at least five reviewers. The program committee held a one-day meeting in Chicago to discuss the papers. The committe held the papers to a very high standard -- nine were selected as full papers and eight as short papers.In addition, the conference includes keynote presentations by Michael Jackson and Linda Northrop, four invited talks on early industrial applications of AOSD, a panel on commercialization of AOSD, and eight demonstrations of AOSD-related tools. Prior to the start of the main conference is a stimulating program of six tutorials and six workshops.
Obvious or not?: regulating architectural decisions using aspect-oriented programming
The construction of complex, evolving software systems requires a high-level design model. However, this model tends not to be enforced on the system, leaving room for the implementors to diverge from it, thus differentiating the designed system from ...
Explicit programming
Many design concepts can be expressed only indirectly in source code. When this occurs, a single concept at design results in a verbose amount of code that is scattered across the system structure. In this paper, we present explicit programming, an ...
Non-modularity in aspect-oriented languages: integration as a crosscutting concern for AspectJ
Aspect-oriented (AO) methods and languages seek to enable the preservation of design modularity through mappings to program structures, especially where common (object-oriented) languages fail to do so. The general claim is made that AO approaches ...
A calculus of superimpositions for distributed systems
A superimposition is a program module that can augment an underlying distributed program with added functionality, while cutting across usual language modularity constructs like processes, packages, or objects. Two ways of combining superimpositions to ...
A semantical approach to method-call interception
We study a language construct superimpose for method-call interception (MCI). The construct enables a programmer to attach additional functionality to certain join points along the execution of specified method calls. This is done in a completely type-...
Incremental programming with extensible decisions
Languages that support incremental programming, that is, the construction of new program components by specifying how they differ from existing components, allow for clean separation of concerns. Object-oriented languages support incremental programming ...
Describing and using non functional aspects in component based applications
One of the major progress due to component based technology is the capability to let the "infrastructure" manage some (non functional or extra functional) aspects such as persistency, distribution and so on without having to change the application code, ...
Using mixins to build flexible widgets
When it comes to software that runs on devices as varied as cell phones, PDAs and desktops, one size does not fit all. This paper describes how mixin layers, a kind of nested generic type, can be used to implement a graphical user interface library that ...
Runtime aspect weaving through metaprogramming
We describe an extension to the Java language, Handi-Wrap, that supports weaving aspects into code at runtime. Aspects in Handi-Wrap take the form of method wrappers, which allow aspect code to be inserted around method bodies like advice in AspectJ. ...
A toolkit for weaving aspect oriented UML designs
Separation of concerns is a basic engineering principle that is also at the core of object-oriented analysis and design methods in the context of the Unified Modeling Language (UML). The UML gives the designer a rich, but somehow disorganized, set of ...
A UML-based aspect-oriented design notation for AspectJ
AspectJ is a well-established programming language for the implementation of aspect-oriented programs. It supports the aspect-oriented programming paradigm by providing a special unit, called "aspect", which encapsulates crosscutting code. While with ...
Towards a standard design language for AOSD
For aspect-oriented software development (AOSD) to live up to being a software engineering method, there must be support for the separation of crosscutting concerns across the development lifecycle. Part of this support is traceability from one ...
Managing crosscutting concerns during software evolution tasks: an inquisitive study
Code is modularized, for many reasons, including making it easier to understand, change, and verify. Aspect-oriented programming approaches extend the kind of code that can be modularized, enabling the modularization of crosscutting code. We conducted ...
Modeling of software concerns in Cosmos
Separation of concerns is a well-established principle of software engineering. Nevertheless, the failure to separate concerns effectively has been identified as a continuing cause of the ongoing software crisis. This failure arises in part because most ...
Separation of coordination in a dynamic aspect oriented framework
Aspect-Oriented Programming separates in a new dimension, named aspect, those features that are spread over different components in a system. In this paper we present a Dynamic AO Framework where software components and aspects are first-order entities ...
Dynamic weaving for aspect-oriented programming
When using Aspect Oriented Programming in the development of software components, a developer must understand the program units actually changed by weaving, how they behave, and possibly correct the aspects used. Support for rapid AOP prototyping and ...
Aspect-oriented programming with model checking
Aspect-oriented programming (AOP) is a programming paradigm such that crosscutting concerns including synchronization policies, resource sharing and performance optimizations over objects are modularized as aspects that are separated from objects. A ...
Cited By
-
Fu Y, Dong Z and He X Architecture-Centered Integrated Verification Modern Software Engineering Concepts and Practices, 10.4018/978-1-60960-215-4.ch005, (104-124)
- Tešanović A, Nyström D, Hansson J and Norström C (2005). Aspects and components in real-time system development: Towards reconfigurable and reusable software, Journal of Embedded Computing, 1:1, (17-37), Online publication date: 1-Jan-2005.
Index Terms
- Proceedings of the 1st international conference on Aspect-oriented software development
Recommendations
Acceptance Rates
| Year | Submitted | Accepted | Rate |
|---|---|---|---|
| MODULARITY '14 | 60 | 21 | 35% |
| AOSD '12 | 79 | 20 | 25% |
| Overall | 139 | 41 | 29% |