We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in “tangled” code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they crosscut the system’s basic functionality. We present the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming.

Building software from reusable components is considered important in reducing development costs. Object-oriented languages such as C++, Smalltalk and Java, however, are not capable of expressing certain aspects of applications in a reusable way. Software engineers may experience difficulties in composing and reusing applications from components, for example if components implement code for multiple views, dynamic inheritance and synchronization [6]. If these aspects have to be programmed, then object -oriented languages may require a considerable amount of redefinition although this may not be intuitively necessary. Several researchers termed these problems as inheritance anomalies, cross-cutting, etc. [12][8][10][11]. Aspectoriented programming aims at addressing these problems by specifying and composing the aspects of a program in a systematic way [10]. Composition-Filters is an aspect-oriented programming technique where different aspects are expressed in Filters as declarative an...

Embedded systems are proliferating at an amazing rate. To be successful these systems must be tailored to meet many cost, time to market, performance, and dependability constraints. Building and tailoring embedded systems by using domain specific components has promise.

We will give some background for AOP. We will present a design philosophy for using aspects on top of an object-oriented paradigm. We will discuss alternative paradigms to which AOP might apply.

A mobile agent is an autonomous computing entity that can migrate from host to host on its own initiative. Over the last few years, numerous systems based on mobile agent technology have been developed because this technology is promising for building customizable, adaptable and robust distributed systems. In practice, to develop a system using mobile agents, one has to overcome new complexities (as well as security/safety problems[5]) arise from the mixed usage of agent primitives. In this position paper, we discuss the need for appropriate support for mobility aspects. We are developing a reflective framework that promote the modularization of the aspects. As a first step towards this goal, we designed and implemented a reflective framework that supports faulthandling behaviors. 1 Aspects of Mobility Consider a round-trip mobile agent. As its primary task, it moves from site to site using its own itinerant strategy and performs a job at each site. To accomplish this task with minim...

Future systems have been characterized as ubiquitous, pervasive, and invisible. They will consist of devices that are diverse in size, performance, and power consumption. Some of these devices will be mobile, posing additional requirements to system software and applications. The focus will move from technology to deployment and ease of use of services. Consequently, traditional paradigms for reasoning about, designing, and implementing software systems and services will no longer be sufficient. We believe that this future vision will rely on a three-tier infrastructure consisting of back-end servers, infrastructure servers, and front-end clients (mobile or static, handheld or embedded). The critical question for future systems will be how to deliver services on demand from back-end servers to resource-constrained clients. If we can handle the new requirements of these systems, we can enable this computing infrastructure to offer significantly more services to users in a more pervasive way.