No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Trap.Net: a Realization of Transparent Shaping in .Net.
Abstract
We define adaptability as the capacity of software in adjusting its behavior in response to changing conditions. To list just a few examples, adaptability is important in pervasive computing, where software in mobile devices need to adapt to dynamic changes in wireless networks; autonomic computing, where software in critical systems are required to be self-manageable; and grid computing, where software for long running scientific applications need to be resilient to hardware crashes and network outages. In this paper, we provide a realization of the transparent shaping programming model, called TRAP.NET, which enables transparent adaptation in existing .NET applications as a response to the changes in the application requirements and/or to the changes in their execution environment. Using TRAP.NET, we can adapt an application dynamically, at run time, or statically, at load time, without the need to manually modify the application original functionality-hence transparent.
... Transparent shaping [65,67,68,74] Component based approaches are one way of providing dynamic integration beyond design and deployment time. ...
The convergence of data, audio and video on IP networks is changing the way individuals, groups and organizations communicate. This diversity of communication media presents opportunities for creating synergistic collaborative communications. This form of collaborative communication is however not without its challenges. The increasing number of communication service providers coupled with a combinatorial mix of offered services, varying Quality-of-Service and oscillating pricing of services increases the complexity for the user to manage and maintain `always best' priced or performance services. Consumers have to manually manage and adapt their communication in line with differences in services across devices, networks and media while ensuring that the usage remain consistent with their intended goals. This dissertation proposes a novel user-centric approach to address this problem. The proposed approach aims to reduce the aforementioned complexity to the user by (1) providing high-level abstractions and a policy based methodology for automated selection of the communication services guided by high-level user policies and (2) providing services through the seamless integration of multiple communication service providers and providing an extensible framework to support the integration of multiple communication service providers. The approach was implemented in the Communication Virtual Machine (CVM), a model-driven technology for realizing communication applications. The CVM includes the Network Communication Broker, the layer responsible for providing a network-independent API to the upper layers of CVM. The initial prototype for the NCB supported only a single communication framework which limited the number, quality and types of services available. Experimental evaluation of the approach show the additional overhead of the approach is minimal compared to the individual communication services frameworks. Additionally the automated approach proposed out performed the individual communication services frameworks for cross framework switching.
The need for adaptability in software is growing, driven in part by the emergence of pervasive and autonomic computing. In many cases, it is desirable to enhance existing programs with adaptive behavior, enabling them to execute effectively in dynamic environments. In this chapter, we introduce an innovative software engineering methodology called transparent shaping that enables dynamic addition of adaptive behavior to existing software systems and applications. We describe an approach to implementing transparent shaping that combines four key software development techniques: aspect-oriented programming to realize separation of concerns at development time, behavioral reflection to support software reconfiguration at run time, component-based design to facilitate independent development and deployment of adaptive code, and adaptive middleware to encapsulate the adaptive functionality. After presenting the general methodology, we discuss two specific realizations of transparent shaping that we have developed and used to create adaptable systems and applications from existing ones.
In the standard generative Model-driven Architecture (MDA), adapting the models of an existing system requires re-generation
and restarting of that system. This is due to a strong separation between the modeling environment and the runtime environment.
Certain current approaches remove this separation, allowing a system to be changed smoothly when the model changes. These
approaches are, however, based on interpretation of modeling information rather than on generation, as in MDA. This paper
describes an architecture that supports fine-grained evolution combined with generative model-driven development. Fine-grained
changes are applied in a generative model-driven way to a system that has itself been developed in this way. To achieve this,
model changes must be propagated correctly toward impacted elements. The impact of a model change flows along three dimensions:
implementation, data (instances), and modeled dependencies. These three dimensions are explicitly represented in an integrated
modeling-runtime environment to enable traceability. This implies a fundamental rethinking of MDA.
This paper proposes an Adaptive CORBA Template (ACT), which enables run-time improvements to CORBA applications in response to unanticipated changes in either their functional requirements or their execution environments. ACT enhances CORBA applications by transparently weaving adaptive code into their object request brokers (ORBs) at run time. The woven code intercepts and adapts the requests, replies, and exceptions that pass through the ORBs. Specifically, ACT can be used to develop an object-oriented framework in any language that supports dynamic loading of code and can be applied to any CORBA ORB that supports portable interceptors. Moreover, ACT can be used to support interoperation among otherwise incompatible adaptive CORBA frameworks. To evaluate the performance and functionality of ACT, we implemented a prototype in Java. Our experimental results show that the overhead introduced by the ACT infrastructure is negligible, while the adaptations offered are highly flexible.
To be in harmony with continuous variations of the execution environment such as fluctuating network bandwidth, decreasing battery power, and so on, new approaches are required for component-based middleware to make them adaptable with regard to these changes. The aim of the work presented in this paper is to enhance the EJB architecture by allowing applications to be aware of, and adapt to, variations in the execution context. We propose to dynamically adapt the association between EJB components and middleware services when necessary. Thus, EJB applications have the advantage to be dynamically adaptive according to changes related to their execution context.
Conventional middleware systems fail to address important issues related to dynamism. Modern computer systems have to deal not only with heterogeneity in the underlying hardware and software platforms but also with highly dynamic environments. Mobile and distributed applications are greatly affected by dynamic changes of the environment characteristics such as security constraints and resource availability. Existing middleware is not prepared to react to these changes.
In many cases, application developers know when adaptive changes in communication and security strategies would improve system performance. But often, they are not able to benefit from it because the middleware lacks the mechanisms to support monitoring (to detect when adaptation should take place) and on-the-fly reconfiguration.
dynamicTAO is a CORBA-compliant reflective ORB that supports dynamic configuration. It maintains an explicit representation of its own internal structure and uses it to carry out runtime customization safely. After describing dynamicTAO’s design and implementation, we discuss our experience on the development of two systems benefiting from the reflective nature of our ORB: a flexible monitoring system for distributed objects and a mechanism for enforcing access control based on dynamic security policies.
This paper describes TRAP/J, a software tool that enables new adaptable behavior to be added to existing Java applications trans- parently (that is, without modifying the application source code and without extending the JVM). The generation process combines behav- ioral reflection and aspect-oriented programming to achieve this goal. Specifically, TRAP/J enables the developer to select, at compile time, a subset of classes in the existing program that are to be adaptable at run time. TRAP/J then generates specific aspects and reflective classes associated with the selected classes, producing an adapt-ready program. As the program executes, new behavior can be introduced via interfaces to the adaptable classes. A case study is presented in which TRAP/J is used to introduce adaptive behavior to an existing audio-streaming application, enabling it to operate effectively in a lossy wireless network by detecting and responding to changing network conditions.
Behavioral reflection is a powerful approach for adapting the behavior of running applications. In this paper we present and motivate partial behavioral reflection, an approach to more efficient and flexible behavioral reflection. We expose the spatial and temporal dimensions of such reflection, and propose a model of partial behavioral reflection based on the notion of hooksets. In the context of Java, we describe a reflective architecture offering appropriate interfaces for static and dynamic configuration of partial behavioral reflection at various levels, as well as Reflex, an open reflective extension for Java implementing this architecture. Reflex is the first extension that fully supports partial behavioral reflection in a portable manner, and that seamlessly integrates load-time and runtime behavioral reflection. The paper shows preliminary benchmarks and examples supporting the approach. The examples, dealing with the observer pattern and asynchronous communication via transparent futures, also show the interest of partial behavioral reflection as a tool for open dynamic Aspect-Oriented Programming.
Self-management is a key feature of autonomic systems. This often demands the dynamic reconguration of a distributed application. An important issue in the reconguration pro- cess is the strategy that is used to coordinate the multiple participants involved in the reconguration. This paper ad- dresses the problem of providing support for multiple recon- guration strategies in autonomic systems that are designed as self-recongurabl e service compositions. We decompose existing strategies in two separate aspects | an orchestra- tion protocol and a local reconguration procedure. This separation allowed us to design a set of generic pluggable components that can be integrated in concrete service com- positions, in order to support dierent strategies. The strat- egy selection is performed according to the semantics of each reconguration. To illustrate our approach, we have imple- mented an instance of these pluggable components for the RAppia composition framework.
This article focuses on aspect oriented programming (AOP) with adaptive methods. According to the author, an operation in an object-oriented program often involves several different collaborating classes. This is done usually by either putting the whole operation into one method on one of the classes or dividing the operation into methods on each of the classes involved. The drawback of the former is that too much information about the structure of classes needs to be tangled into each such method, which makes it difficult to adapt to changes in the class structure. The latter, scatters the operation across multiple classes, making it difficult to adapt when the operation changes. To resolve this conflict, adaptive methods have been developed which encapsulate the behaviour of an operation into one place, avoiding thereby the scattering problem. Moreover, abstracting over the class structure also avoids the tangling problem as well. In adaptive methods, the behaviour is expressed as a high-level description of how to reach the participants of the computation.
It has been demonstrated that certain design concerns, such as access control, synchronization, and object interactions cannot be expressed in current OO languages as a separate software module [4, 7]. These so-called crosscutting concerns generally result in implementations scattered over multiple operations. If a crosscutting concern cannot be treated as a single module, its adaptability and reusability are likely to be reduced. A number of programming techniques have been proposed to express crosscutting concerns, for example, adaptive programming [9], AspectJ [8], Hyperspaces [10], and Composition Filters [1]. Here, we present the Composition Filters (CF) model and illustrate how it addresses evolving crosscutting concerns.
Thesis (Ph. D.) --Michigan State University. Dept. of Computer Science and Engineering, 2004. Includes bibliographical references (leaves 175-192). Microfiche. s
A replication logic is the set of protocols and mechanisms implementing a software replication technique. A three-tier approach to replication consists in separating the replication logic from both clients and replicated servers by embedding such logic in a middle-tier In this paper we first introduce the fundamental concepts underlying three-tier replication. This approach has two main practical advantages: (i) it allows to maintain consistency among the state of server replicas deployed within an asynchronous distributed system and (ii) it supports very thin clients. Then we present the Interoperable Replication Logic (IRL) architecture, which is a Fault Tolerant CORBA compliant infrastructure exploiting a three-tier approach to replicate stateful deterministic CORBA objects. In this context, we illustrate the three-tier replication protocol currently implemented in our IRL prototype and a performance analysis that shows the feasibility of the three-tier approach to software replication.
Compositional adaptation is one of the two general approaches to implementing software adaptation. This approach exchanges algorithmic or structural system components with others that improve a program's fit to its current environment. With compositional adaptation, an application can adopt new algorithms for addressing concerns that were unforeseen during development. This flexibility not only supports tuning of program variables or strategy selection but also allows dynamic recomposition of the software during execution.
A replication logic is the set of protocols and mechanisms implementing a software replication technique. A three-tier approach to replication consists in separating the replication logic from both clients and replicated servers by embedding such logic in a middle-tier.
Recomposable software enables a system to change its structure and behavior during execution, in response to a dynamic execution environment. This paper proposes an approach to ensure that such adaptations are safe with respect to system consistency. The proposed method takes into consideration dependency analysis for target components, specifically determining viable sequences of adaptive actions and those states in which an adaptive action may be applied safely. We demonstrate the technique that ensures safe adaptation (insertion, removal, and replacement of components) in response to changing external conditions in a wireless multicast video application.
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 cross-cut 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.
The standard reflection API of Java provides the ability to introspect a program but not to alter program behavior. This paper
presents an extension to the reflection API for addressing this limitation. Unlike other extensions enabling behavioral reflection,
our extension called Javassist enables structural reflection in Java. For using a standard Java virtual machine (JVM) and avoiding a performance problem,
Javassist allows structural reflection only before a class is loaded into the JVM. However, Javassist still covers various
applications including a language extension emulating behavioral reflection. This paper also presents the design principles
of Javassist, which distinguish Javassist from related work.
Many real-time application domains can benefit from flexible and open distributed architectures, such as those defined by the CORBA specification. CORBA is an architecture for distributed object computing being standardized by the OMG. Although CORBA is well-suited for conventional request/response applications, CORBA implementations are not yet suited for real-time applications due to the lack of key quality of service (QoS) features and performance optimizations.This paper makes three contributions to the design of real-time CORBA systems. First, the paper describes the design of TAO, which is our high-performance, real-time CORBA 2.0-compliant implementation that runs on a range of OS platforms with real-time features including VxWorks, Chorus, Solaris 2.x, and Windows NT. Second, it presents TAO's real-time scheduling service that can provide QoS guarantees for deterministic real-time CORBA applications. Finally, the paper presents performance measurements that demonstrate the effects of priority inversion and non-determinism in conventional CORBA implementations and how these hazards are avoided in TAO.
The need to dynamically modify running applications arises in systems that must adapt to changes in their environment, in
updating long-running systems that cannot be halted and restarted, and in monitoring and debugging systems without the need
to recompile and restart them. Relatively few architectures have explored the meaning and possibilities of applying behavioural
modifications to already running applications without static preparation of the application. The desirable characteristics
of an architecture for dynamic modification include support for non-invasive association of new behaviour with the application,
support for modular reusable components encapsulating the new behaviour and support for dynamic association (and de-association)
of new behaviour with any class or object of the application. The Iguana/J architecture explores unanticipated dynamic modification,
and demonstrates how these characteristics may be supported in an interpreted language without extending the language, without
a preprocessor, and without requiring the source code of the application. This paper describes the Iguana/J programmer’s model
and how it addresses some acknowledged issues in dynamic adaptation and separation of concerns, describes how Iguana/J is
implemented, and gives examples of applying Iguana/J.
Simplifying development, evolution, and integration of Java using Hyper/J.
The Eternal system supports networked enterprise applications that
must operate continuously 24 hours per day, 7 days per week. Based on
the CORBA standard, Eternal provides object replication not only for
fault tolerance but also for live software upgrades, as well as resource
management facilities. Through the use of interceptors, Eternal renders
the object replication transparent to the application, as well as to the
ORB and to the operating system. Thus, Eternal works with commercial
off-the-shelf CORBA ORBs and standard unmodified operating systems.
Eternal handles the difficult issues of object replication, fault
tolerance, live upgrades and resource management, thereby allowing the
application programmers to focus on the applications
This paper proposes an approach to the design of configurable and open middleware platforms based on the concept of reflection. More specifically, the paper introduces a language-independent reflective architecture featuring a perobject meta-space, the use of meta-models to structure meta-space, and a consistent use of object graphs for composite components. This is complemented by a component framework supporting the construction of meta-spaces. The paper also reports on experiences of implementing the architecture (with emphasis on experiments with open bindings). Keywords Middleware, (re-)configuration, reflection, open implementation, open bindings. 1 INTRODUCTION Middleware has emerged as an important architectural component in supporting distributed applications. The role of middleware is to present a unified programming model to application writers and to mask out problems of heterogeneity and distribution. The importance of the topic is reflected in the increasing visibili...
Current implementations of reflective Java extensions typically either require access to source code, or require a modified Java platform. This makes them unsuitable for applying reflection to Commercial-off-the-Shelf (COTS) systems. In order to address this we developed a prototype Java extension Dalang based on class wrapping that worked with compiled code, and was implemented using a standard Java platform. In this paper we evaluate the class wrapper approach, and discuss issues that relate to the transparent application of reflection to COTS systems. This has informed our design of a new version of Dalang called Kava that implements a metaobject protocol through the application of standard byte code transformations. Kava leverages the capabilities of byte code transformation toolkits whilst presenting a high-level abstraction for specifying behavioural changes to Java components.
this paper we discuss four major problems we have observed in our developing and deploying wide-area distributed object applications and middleware. First, most programs are developed ignoring the variable wide area conditions. Second, when application programmers do try to handle these conditions, they have great difficulty because these harsh conditions are different from thost of the local objects they are used to dealing with. Third, IDL hides information about the tradeoffs any implementation of an object must make. Fourth, there is presently no way to systematically reuse current technology components which deal with these conditions, so code sharing becomes impractical.
An architecture for next gener-ation middleware The Lake Dis-trict
- G S Blair
- G Coulson
- P Robin
- M Papathomas
G. S. Blair, G. Coulson, P. Robin and M. Papathomas, An architecture for next gener-ation middleware, in Proceedings of the IFIP International Conference on Distributed Systems Platforms and Open Distributed Processing (Middleware'98), The Lake Dis-trict, England (1998).
JAC: A flexible and efficient solution for aspect-oriented programming in Java
- R Pawlak
- L Seinturier
- L Duchien
- G Florin
R. Pawlak, L. Seinturier, L. Duchien and G. Florin, JAC: A flexible and efficient solution for aspect-oriented programming in Java, in Proceedings of Reflection 2001, LNCS 2192, 2001, pp. 1–24.
mKernel: A manageable kernel for EJB-based enterprise appli-cations
- J Bruhn
- G Wirtz
J. Bruhn and G. Wirtz, mKernel: A manageable kernel for EJB-based enterprise appli-cations, in Proceedings of the First International Conference on Autonomic Computing and Communication Systems (Autonomics 2007), 2007.
Bouraqadi-Saadani, Two-step weaving with reflection using AspectJ
- P C David
- T Ledoux
P. C. David, T. Ledoux and N. M. N. Bouraqadi-Saadani, Two-step weaving with reflection using AspectJ, in OOPSLA 2001 Workshop on Advanced Separation of Con-cerns in Object-Oriented Systems, Tampa, 2001.
Aspect.NET — an aspect-oriented programming tool for Microsoft.NET
- O Vladimir
- Safonov
Vladimir O. Safonov, Aspect.NET — an aspect-oriented programming tool for Microsoft.NET, in Microsoft Research SSCLI RFP II Capstone Workshop 2005, September 2005.
Reflection and Software Engineering
- I Welch
- R J Stroud
Dalang — a reflective extension for Java, technical report CS-TR-672
- I Welch
- R Stroud