By using different interface adapters for different methods, it is possible to construct a maximally covering web of interface adapters which incurs minimum loss during interface adaptation. We introduce a polynomial-time algorithm that can achieve this. However, we also show that minimizing the number of adapters included in a maximally covering web of interface adapters is an NP-complete problem.
@cite_2 proposes an interface adaptation framework which attempts to minimize the loss incurred by an interface adapter chain, and @cite_3 rigorously defines the mathematical background required to implement such a framework. These only consider the use of single chains of interface adapters.
@cite_3 @cite_2
2052260075 2132136548 2000434158 112403282
Despite providing similar functionality, multiple network services may require the use of different interfaces to access the functionality, and this problem will only become worse with the widespread deployment of ubiquitous computing environments. One way around this problem is to use interface adapters that adapt one interface into another. Chaining these adapters allows flexible interface adaptation with fewer adapters, but the loss incurred because of imperfect interface adaptation must be considered. This study outlines a matrix-based mathematical basis for analysing the chaining of lossy interface adapters. The authors also show that the problem of finding an optimal interface adapter chain is NP-complete with a reduction from 3SAT. A key feature of ubiquitous computing is service continuity which allows a user to transparently continue his task regardless of his movement. For service continuity, the underlying system needs to not only discover a service satisfying a user's request, but also provide an interface differences resolution scheme if the interface of the service found is not the same as that of the service requested. For resolving interface mismatches, one of solutions is to use an interface adapter. The most serious problem in the interface adapter-based approach is the overhead of adapter generation. There are many research efforts about adapter generation load reduction and this paper focuses on an adapter chaining scheme to reduce the number of necessary adapters among different service interfaces. We propose a construction-time adaptation loss evaluation scheme and an adapter chain construction algorithm, which finds an adapter chain with minimal adaptation loss. In this paper, we define the problem of simultaneously deploying multiple versions of a web service in the face of independently developed unsupervised clients. We then propose a solution in the form of a design technique called Chain of Adapters and argue that this approach strikes a good balance between the various requirements. We recount our experiences in automating the application of the technique and provide an initial analysis of the performance degradations it may occasion. The Chain of Adapters technique is particularly suitable for self-managed systems since it makes many version-related reconfiguration tasks safe, and thus subject to automation. Modern, complex software systems (e-commerce, IT, critical infrastructures, etc.) are increasingly required to continue operation in the face of change, to self-adapt to accommodate shifting user priorities, resource variability, changing environments, and component failures. While manual oversight benefits from global problem contexts and flexible policies, human operators are costly and prone to error. Low-level, embedded mechanisms (exceptions, time-outs, etc.) are effective and timely for error recovery, but are local in scope to the point-of-failure, application-specific, and costly to modify when adaptation objectives change. An ideal solution leverages domain expertise, provides an end-to-end system perspective, adapts the system in a timely manner, and can be engineered cost-effectively. Architecture-based self-adaptation closes the “loop of control,” using external mechanisms and the architecture model of the target system to adapt the system. An architecture model exposes important system properties and constraints, provides end-to-end problem contexts, and allows principled and automated adaptations. Existing architecture-based approaches specialize support for particular classes of systems and fixed sets of quality-of-service concerns; they are costly to develop for new systems and to evolve for new qualities. To overcome these limitations, we posit this thesis: We can provide software engineers the ability to add and evolve self-adaptation capabilities cost-effectively, for a wide range of software systems, and for multiple objectives, by defining a self-adaptation framework that factors out common adaptation mechanisms and provides explicit customization points to tailor self-adaptation capabilities for particular classes of systems, for multiple quality-of-service objectives. Our approach, embodied in a system called Rainbow, provides an engineering approach and a framework of mechanisms to monitor a target system and its environment, reflect observations into the system's architecture model, detect opportunities for improvements, select a course of action, and effect changes. The framework provides general and reusable infrastructures with well-defined customization points, a set of abstractions, and an adaptation engineering process, focusing engineers on adaptation concerns to systematically customize Rainbow to particular systems. To automate system self-adaptation, Rainbow provides a language, called Stitch, to represent routine human adaptation knowledge using a core set of adaptation concepts.