Pasqualina Potena

An optimization framework for build-or-buy decisions in software architecture

Building a software architecture that meets functional requirements is a quite consolidated activity, whereas keeping high quality attributes is still an open challenge. In this paper we introduce an optimization framework that supports the decision whether to buy software components or to build them in-house upon designing a software architecture. We devise a non-linear cost/quality optimization model based on decision variables indicating the set of architectural components to buy and to build in order to minimize the software cost while keeping satisfactory values of quality attributes. From this point of view, our tool can be ideally embedded into a Cost Benefit Analysis Method to provide decision support to software architects. The novelty of our approach consists in building costs and quality attributes on a common set of decision variables related to software development. We start from a special case of the framework where the quality constraints are related to the delivery time and the product reliability, and the model solution also devises the amount of unit testing to be performed on built components. We generalize the framework formulation to represent a broader class of architectural cost-minimization problems under quality constraints, and discuss advantages and limitations of such approach.

Automated selection of software components based on cost/reliability tradeoff

Functional criteria often drive the component selection in the assembly of a software system. Minimal distance strategies are frequently adopted to select the components that require minimal adaptation effort. This type of approach hides to developers the non-functional characteristics of components, although they may play a crucial role to meet the system specifications. In this paper we introduce the CODER framework, based on an optimization model, that supports “build-or-buy” decisions in selecting components. The selection criterion is based on cost minimization of the whole assembly subject to constraints on system reliability and delivery time. The CODER framework is composed by: an UML case tool, a model builder, and a model solver. The output of CODER indicates the components to buy and the ones to build, and the amount of testing to be performed on the latter in order to achieve the desired level of reliability.

Adaptation space exploration for service-oriented applications

Service-oriented applications may require adaptation to tackle changing user needs, system intrusions or faults, changing operational environment, resource variability, etc. In order to achieve the right trade off among the functional requirements, software qualities (such as performance and reliability) and the adaptation cost itself, the adaptation decisions should involve the (a priori) evaluation of new alternatives to the current application design. However, the generation and evaluation of design alternatives is often time-consuming, it can be error-prone and can lead to suboptimal design decisions, especially if carried out manually by system maintainers.This article proposes an automatic optimization process for adaptation space exploration of service-oriented applications based on trade-offs between functional and extra-functional requirements. The proposed method combines the use of metaheuristic search techniques and functional/extra-functional patterns (i.e., architectural design patterns and tactics). Besides, the proposed methodology relies on the standard Service Component Architecture (SCA) for heterogeneous service assembly and its runtime platforms. As a proof-of-concept, this article provides also an example of instantiation of the process together with an experimentation on a sample application and a numerical evaluation of the scalability of the approach. We propose a process for the adaptation of service-oriented applications.It is based on an optimization method.It is based on trade-offs between functional and extra-functional requirements.It uses metaheuristic search techniques and functional/extra-functional patterns.

Optimization of adaptation plans for a service-oriented architecture with cost, reliability, availability and performance tradeoff

A service-based system may require adaptation for several reasons, such as service evolution (e.g., a new version may be available), hardware volatility (e.g., network quality changes), and varying user demands and new requirements (e.g., a new functionality or a different level of quality of service). Therefore, it is suitable to dynamically adapt a service-based system in an automated manner. However, service adaptations often do not consider software quality attributes and, if they do, they relay on a single attribute in isolation. In this paper, we present an optimization model, which aims to minimize the adaptation costs of a Service-Oriented Architecture (SOA), in correspondence with a certain change scenario (i.e., a set of new requirements) under reliability, availability and performance tradeoff. The model predicts the quality of the new SOA obtained by changing both its structure and behavior. Specifically, it suggests how to replace existing services with available instances and/or adding new services, and how to remove or introduce interaction(s) between existing services and/or new services. We show how our model works on a smartphone mobile application example, and through the sensitivity analysis we highlight its potential to drive architectural decisions.

Self-Adaptation of Service Based Systems Based on Cost/Quality Attributes Tradeoffs

An application should be self-adaptive in order to automatically and autonomously adapt its behavior for several reasons, such as service evolution (e.g. a new version may be available), hardware volatility (e.g. network quality changes) and varying users demands with new requirements (e.g. a new functionality or a different level of quality of service). In this paper we introduce a framework, based on an optimization model, that dynamically adapts a service based system (i.e. both the structural and behavioral software and hardware architecture) while minimizing the adaptation costs and guaranteeing a required level of the system qualities. Adaptation actions can be triggered both by an user request and/or automatically after the runtime violation of system quality constraints, or the appearing/disappearing of services into the environment. In particular, in this paper we give a general overview of the main components of the framework by providing a deeper discussion of the optimization model that is the core of the framework.

A reliability model for Service Component Architectures

Graphical abstractDisplay Omitted HighlightsIt is proposed a reliability model for Service Component Architectures described in the lightweight formal language SCA-ASM.SCA-ASM is based on the OASIS standard Service Component Architecture (SCA) and on the formal method Abstract State Machines (ASMs).The proposed reliability prediction method exploits ideas from architecture-based and path-based reliability models.A set of experimental results show the effectiveness of the proposed approach and its comparison with a state-of-the art BPEL-based approach. Service-oriented applications are dynamically built by assembling existing, loosely coupled, distributed, and heterogeneous services. Predicting their reliability is very important to appropriately drive the selection and assembly of services, to evaluate design feasibility, to compare design alternatives, to identify potential failure areas and to maintain an acceptable reliability level under environmental extremes.This article presents a model for predicting reliability of a service-oriented application based on its architecture specification in the lightweight formal language SCA-ASM. The SCA-ASM component model is based on the OASIS standard Service Component Architecture for heterogeneous service assembly and on the formal method Abstract State Machines for modeling service behavior, interactions, and orchestration in an abstract but executable way.The proposed method provides an automatic and compositional means for predicting reliability both at system-level and component-level by combining a reliability model for an SCA assembly involving SCA-ASM components, and a reliability model of an SCA-ASM component. It exploits ideas from architecture-based and path-based reliability models. A set of experimental results shows the effectiveness of the proposed approach and its comparison with a state-of-the art BPEL-based approach.

Analysis of Non-functional Properties in Software Product Lines: A Systematic Review

Software Product Lines (SPL) approach has been widely developed in academia and successfully applied in industry. Based on the selection of features, stakeholders can efficiently derive tailor-made programs satisfying different requirements. While SPL was very successful at building products based on identified features, achievements and preservation of many nonfunctional properties (NFPs) remain challenging. A knowledge how to deal with NFPs is still not fully obtained. In this paper, we present a systematic literature review of NFPs analysis for SPL products, focusing on runtime NFPs. The goal of the paper is twofold: (i) to present an holistic overview of SPL approaches that have been reported regarding the analysis of runtime NFPs, and (ii) to categorize NFPs treated in the scientific literature regarding development of SPLs. We analyzed 36 research papers, and identified that system performance attributes are typically the most considered. The results also aid future research studies in NFPs analysis by providing an unbiased view of the body of empirical evidence and by guiding future research directions.

Reliability Prediction for Service Component Architectures with the SCA-ASM Component Model

In service-oriented computing, software applications are dynamically built by assembling existing, loosely-coupled, distributed, and heterogeneous services. Predicting their reliability is important to appropriately drive the selection and assembly of services. This paper presents an approach to predict the reliability of a service component architecture. We adopt a lightweight formal component model, SCA-ASM, as core modeling technique for both architecture and behavior, supported by a run-time platform. This component model is based on the OASIS standard Service Component Architecture for heterogeneous service assembly and on the formal method Abstract State Machines for modeling service behavior, interactions, and orchestration in an abstract but executable way. The proposed reliability prediction method exploits ideas from architecture-based and path-based reliability models.

Selecting Optimal Maintenance Plans Based on Cost/Reliability Tradeoffs for Software Subject to Structural and Behavioral Changes

Software maintenance is assuming ever more a crucial role in the lifecycle due to the high variability of software requirements and environment. New development paradigms are being defined to support the numerous decisions that have to be taken after the software deployment. On the basis of the increasing request of software quality, nonfunctional attributes should enter in the decisional process to avoid changes that compromise the software quality. In this paper we define an optimization model that drives the choice of a maintenance plan (i.e. a set of maintenance actions to be taken) in correspondence of a certain change scenario. A change scenario is a set of new requirements that induce changes in the structural and behavioral architecture of the software system. The solution of such model, as shown in this paper on a mobile application, provides the set of actions that minimize the maintenance cost while guaranteeing a certain level of software reliability. We also show how this instrument can be used to perform a sensitivity analysis of maintenance plans vs cost/reliability tradeoff.

How Can Optimization Models Support the Maintenance of Component-Based Software?

The maintenance phase of software systems is ever more increasing its incidence, in terms of effort, to the whole software lifecycle. Therefore the introduction of automated techniques that can help software maintainers to take decision on the basis of quantitative evaluation would be a suitable phenomenon.Search-based techniques offer today a very promising view on the automation of searching processes in the software engineering domain. Component-based software is a very interesting paradigm to apply such type of techniques, for example for component selection. In this paper we introduce optimization techniques to manage the problem of failures at maintenance time. In particular,we introduce two approaches that provide maintenance actions to betaken in order to overcome system failures in case of monitored and non-monitored software systems.