Resolving Architectural Mismatches of COTS Through Architectural Reconciliation

The integration of COTS components into a system under development entails architectural mismatches. These have been tackled, so far, at the component level, through component adaptation techniques, but they also must be tackled at an architectural level of abstraction. In this paper we propose an approach for resolving architectural mismatches, with the aid of architectural reconciliation. The approach consists of designing and subsequently reconciling two architectural models, one that is forward-engineered from the requirements and another that is reverse-engineered from the COTS-based implementation. The final reconciled model is optimally adapted both to the requirements and to the actual COTS-based implementation. The contribution of this paper lies in the application of architectural reconciliation in the context of COTS-based software development. Architectural modeling is based upon the UML 2.0 standard, while the reconciliation is performed by transforming the two models, with the help of architectural design decisions.

An Approach to Autonomizing Legacy Systems

Adding adaptation capabilities to existing distributed systems is a major concern. The question addressed here is how to retrofit existing systems with self-healing, adaptation and/or self management capabilities. The problem is obviously intensified for 'systems of systems' composed of components, whether new or legacy, that may have been developed by different vendors, mixing and matching COTS and 'open source' components. This system composition model is expected to be increasingly common in high performance computing. The usual approach is to train technicians to understand the complexities of these components and their connections, including performance tuning parameters, so that they can then manually monitor and reconfigure the system as needed. We envision instead attaching a 'standard' feedback loop infrastructure to existing distributed systems for the purposes of continual monitoring and dynamically adapting their activities and performance. (This approach can also be applied to 'new' systems, as an alternative to 'building in' adaptation facilities, but we do not address that here.) Our proposed infrastructure consists of multiple layers with the objectives of probing, measuring and reporting of activity and state within the execution of the legacy system among its components and connectors; gauging, analysis and interpretation of the reported events; and possible feedback to focus the probes and gauges to drill deeper, or when necessary - direct but automatic reconfiguration of the running system

An Instance-Oriented Approach to Constructing Product Lines from Layers

The Model/View/Controller (MVC) paradigm, and its many variants, is a cornerstone of decoupling within object-oriented design. MVC leads to clear reuse benefits regarding the class hierarchies for the model and view elements. In practice, however, the controllers appear to defy reuse, most likely because they encapsulate specialized business logic. Within an effective product line, however, such specialized logic must be reused. We combine the MVC paradigm with feature-oriented programming (FOP) to produce a novel instance-oriented design pattern for layers that brings reusability back to controllers. We demonstrate the effectiveness of our approach using a product-line example of a solitaire game engine

A Platform-based Design Approach for Flexible Software Components

We develop a design method that promotes flexible component design based on a common component platform with various plug-ins. The approach increases the flexibility and expandability of software components, which improves their reuse opportunities. We argue that such a flexible component design can expand reuse from relatively small infrastructure items, such as user interfaces, printing functionality, and data access modules, to the core of the application domain. Reusing such domain-specific items helps realize the true value of component-based software development. Following a design science research approach, we evaluated the component design method by assessing its correctness and its application to different scenarios. We also recruited a panel of experts to assess it

Achieving seamless component composition through scenario-based deep adaptation and generation

Mismatches between pre-qualified existing components and the particular reuse context in applications have been a major factor hindering component reusability and successful composition. Although component adaptation has acted as a key solution of eliminating these mismatches, deep adaptation is often either impossible or incurring heavy overheads in the components. This paper proposes an approach, namely Scenario-based dynamic component Adaptation and Generation (SAGA), to achieve deep adaptation with little code overhead through XML-based component specification, interrelated adaptation scenarios and corresponding component adaptation and generation

Generative aspect-oriented component adaptation

Due to the availability of components and the diversity of target applications, mismatches between pre-qualified existing components and the particular reuse context in applications are often inevitable and have been a major hurdle of component reusability and successful composition. Although component adaptation has acted as a key solution for eliminating these mismatches, existing practices are either only capable for adaptation at the interface level, or require too much intervention from software engineers. Another weakness of existing approaches is the lack of reuse of component adaptation knowledge. Aspect Oriented Programming (AOP) is a new methodology that provides separation of crosscutting concerns by introducing a new unit of modularization - an Aspect that crosscuts other modules. In this way, all the associated complexity of the crosscutting concerns is isolated into the Aspects, hence the final system becomes easier to design, implement and maintain. The nature of AOP makes it particularly suitable for addressing non-functional mismatches with component-based systems. However, current AOP techniques are not powerful enough for efficient component adaptation due to the weaknesses they have, including the limited reusability of Aspects, platform specific Aspects, and naive weaving processes. Therefore, existing AOP technology needs to be expanded before it can be used for efficient component adaptation. This thesis presents a highly automated approach to component adaptation through product line based Generative Aspect Oriented Component adaptation. In the approach, the adaptation knowledge is captured in Aspects and aims to be reusable in various adaptation circumstances. Automatic generation of adaptation Aspects is developed as a key technology to improve the level of automation of the approach and the reusability of adaptation knowledge. This generation is realised by developing a two dimensional Aspect model, which incorporates the technologies of software product line and generative programming. The adaptability and automation of the approach is achieved in an Aspect oriented component adaptation framework by generating and then applying the adaptation Aspects under a designed weaving process according to specific adaptation requirements. To expand the adaptation power of AOP, advanced Aspect weaving processes have been developed with the support of an enhanced aspect weaver. To promote the reusability of adaptation Aspects, an expandable repository of reusable adaptation Aspects has been developed based on the proposed two-dimensional Aspect model. A prototype tool is built as a leverage of the approach and automates the adaptation process. Case studies have been done to illustrate and evaluate the approach, in terms of its capability of building highly reusable Aspects across various AOP platforms and providing advanced weaving process. In summary, the proposed approach applies Generative Aspect Oriented Adaptation to targeted components to correct the mismatch problem so that the components can be integrated into a target application easily. The automation of the adaptation process, the deep level of the adaptation, and the reusability of adaptation knowledge are the advantages of the approach.EThOS - Electronic Theses Online ServiceGBUnited Kingdo