Existing methods used for service discovery assume that the world is static, con- sidering a predetermined set of attributes. As a result, current discovery techniques return many results that are irrelevant. Our approach to high quality service dis- covery improves the results’ relevancy by considering dynamic attributes with values changing over time. Using this approach, we reveal structure from the data to satisfy the consumers’ experiences. Web service quality is a set of dynamic attributes used to rank services with similar functionalities. When picking a service to execute financial transactions effi- ciently, we might consider availability, reliability, response time, and transaction cost as quality indicators. Supporting dynamic attributes is a feature critical to providing exceptional quality service discovery. In addition, effective service discovery requires detailed context models that describe both static and dynamic features. The context takes into consideration the situation of the service, the operating environment, the users’ circumstances, and their preferences. For instance, latency is an important issue in stock trading services with direct impact on revenue. One of the main challenges in enabling dynamic service discovery is developing techniques and models to handle the novel aspects of the web service paradigm. This challenge leads to a variety of research questions related to measuring, monitoring, or querying of dynamic attributes, while guaranteeing integrity and validity. We outline an architecture framework called Static Discovery Dynamic Selection (SDDS) to gather and manage dynamic attributes considering both context and do- main information at discovery time—augmenting static mechanisms. The architec- ture of SDDS defines individual components that collectively satisfy flexible and ac- curate service selection with a robust resource management approach capable of con- sidering high-frequency data. Moreover, we devised a multi-criteria decision making algorithm that considers the knowledge domain and the user context, and accordingly, the algorithm returns a small set of accurate and reliable results. As part of the SDDS framework, autonomic computing adds self-adaptability by taking highly dynamic context information into account. The impact of our method is demonstrated in an implementation of the model. We demonstrate that increasing the adaptability of the web service discovery by including context information provides a noticeable reduction in the number of results returned compared to static web service discovery methods. We extend the proposed infrastructure to ascertain whether a particular service satisfies, at execution time, specific security properties. We introduce the notion of certified web service assurance, characterizing how consumers of the service can specify the set of security properties that a service should satisfy. In addition, we illustrate a mechanism to re-check security properties when the execution context changes. To this end, we introduce the concept of a context-aware certificate and describe a dynamic, context-aware service discovery environment. / Graduate

Submitted by Kleber Silva (kleberbs@ufba.br) on 2017-05-31T20:12:19Z No. of bitstreams: 1 tese-sandroandrade-2014.pdf: 6962942 bytes, checksum: 6e55349061fd33f307cf9f2896c56436 (MD5) / Approved for entry into archive by Vanessa Reis (vanessa.jamile@ufba.br) on 2017-06-07T10:57:53Z (GMT) No. of bitstreams: 1 tese-sandroandrade-2014.pdf: 6962942 bytes, checksum: 6e55349061fd33f307cf9f2896c56436 (MD5) / Made available in DSpace on 2017-06-07T10:57:54Z (GMT). No. of bitstreams: 1 tese-sandroandrade-2014.pdf: 6962942 bytes, checksum: 6e55349061fd33f307cf9f2896c56436 (MD5) / Ao longo dos últimos anos, uma série de novas demandas contribuíram para aumentar ainda mais a complexidade essencial de sistemas de software. Como consequência, desenvolver sistemas computacionais que atendam satisfatoriamente a essas demandas requer um controle intelectual que rapidamente se aproxima dos limites humanos. Os Sistemas Self-Adaptive (SSA) representam uma solução promissora para este problema. Um SSA é caracterizado pela transferência, para run-time, de uma ou mais atividades do processo de desenvolvimento de software, suportadas por uma infraestrutura de adaptação que permite o raciocínio e execução automáticos de atividades antes realizadas off-line pelos desenvolvedores. Esta tese apresenta o projeto, implementação e avaliação de uma abordagem para projeto arquitetural automatizado de SSA, baseada na representação sistemática de conhecimento refinado de projeto e na aplicação de técnicas de otimização multiobjetivo. Para isso, uma nova linguagem (DuSE) para especificação de espaços de projeto e métricas de qualidade particulares a um determinado domínio de aplicação foi proposta, associada a uma plataforma de otimização de arquiteturas de software. A DuSE viabilizou a infraestrutura de metamodelagem necessária para a especificação do SA:DuSE -- espaço de projeto responsável pela captura sistemática das principais dimensões de projeto de SSA baseados em teoria de controle. A abordagem foi avaliada em relação à sua capacidade de manifestação de trade-offs, potencial de antecipação dos atributos de qualidade evidenciados e impacto na efetividade e complexidade dos projetos quando comparada a abordagens alternativas. Resultados indicam que a abordagem efetivamente captura o caráter multiobjetivo do projeto de SSA e que promove um melhor suporte à investigação de alternativas e tomada de decisão no projeto de aplicações deste domínio.

No / Self-adaptive systems are evolving systems that can adjust their behaviour to accommodate dynamic requirements or to better serve the goal. These systems can vary in their architecture, operation, or adaptive strategies based on the application. Moreover, the evaluation can happen in different ways depending on system architecture and its requirements. Self-adaptive systems can be prone to situations like adaptation faults, inconsistencies in context or low performance on tasks due to their dynamism and complexity. That is why it is important to have reliability assurance of the system to monitor such situations which can compromise the system functionality. In this paper, we provide a brief background on different types of self-adaptive systems and various ways a system can evolve. We discuss the different mechanisms that have been applied in the last two decades for reliability evaluation of such systems and identify challenges and limitations as research opportunities related to the self-adaptive system’s reliability evaluation. / This research was undertaken as a part of the “Model-based Reliability Evaluation for Autonomous Systems with Evolving Architectures” project funded by the University of Bradford under the SURE Grant scheme.

Ensuring the resilience of self-adaptive systems used in critical infrastructure systems is a concern as their failure has severe societal and financial consequences. The current trends in the growth of the scale and complexity of society's workload demands and the systems built to cope with these demands increases the anxiety surrounding service disruptions. Self-adaptive mechanisms instill dynamic behavior to systems in an effort to improve their resilience to runtime changes that would otherwise result in service disruption or failure, such as faults, errors, and attacks. Thus, the evaluation of a self-adaptive system's resilience is critical to ensure expected operational qualities and elicit trust in their services. However, resilience benchmarking is often overlooked or avoided due to the high cost associated with evaluating the runtime behavior of large and complex self-adaptive systems against an almost infinite number of possible runtime changes. Researchers have focused on techniques to reduce the overall costs of benchmarking while ensuring the comprehensiveness of the evaluation as testing costs have been found to account for 50 to 80% of total system costs. These test suite minimization techniques include the removal of irrelevant, redundant, and repetitive test cases to ensure that only relevant tests that adequately elicit the expected system responses are enumerated. However, these approaches require an exhaustive test suite be defined first and then the irrelevant tests are filtered out, potentially negating any cost savings. This dissertation provides a new approach of defining a resilience changeload for self-adaptive systems by incorporating goal-oriented requirements engineering techniques to extract system information and guide the identification of relevant runtime changes. The approach constructs a goal refinement graph consisting of the system's refined goals, runtime actions, self-adaptive agents, and underlying runtime assumptions that is used to identify obstructing conditions to runtime goal attainment. Graph theory is then used to gauge the impact of obstacles on runtime goal attainment and those that exceed the relevance requirement are included in the resilience changeload for enumeration. The use of system knowledge to guide the changeload definition process increased the relevance of the resilience changeload while minimizing the test suite, resulting in a reduction of overall benchmarking costs. Analysis of case study results confirmed that the new approach was more cost effective on the same subject system over previous work. The new approach was shown to reduce the overall costs by 79.65%, increase the relevance of the defined test suite, reduce the amount of wasted effort, and provide a greater return on investment over previous work by a factor of two.

Software-intensive systems are increasingly expected to operate under changing and uncertain conditions, including not only varying user needs and workloads, but also fluctuating resource capacity. Self-adaptation is an approach that aims to address this problem, giving systems the ability to change their behavior and structure to adapt to changes in themselves and their operating environment without human intervention. Self-adaptive systems tend to be reactive and myopic, adapting in response to changes without anticipating what the subsequent adaptation needs will be. Adapting reactively can result in inefficiencies due to the system performing a suboptimal sequence of adaptations. Furthermore, some adaptation tactics—atomic adaptation actions that leave the system in a consistent state—have latency and take some time to produce their effect. In that case, reactive adaptation causes the system to lag behind environment changes. What is worse, a long running adaptation action may prevent the system from performing other adaptations until it completes, further limiting its ability to effectively deal with the environment changes. To address these limitations and improve the effectiveness of self-adaptation, we present proactive latency-aware adaptation, an approach that considers the timing of adaptation (i) leveraging predictions of the near future state of the environment to adapt proactively; (ii) considering the latency of adaptation tactics when deciding how to adapt; and (iii) executing tactics concurrently. We have developed three different solution approaches embodying these principles. One is based on probabilistic model checking, making it inherently able to deal with the stochastic behavior of the environment, and guaranteeing optimal adaptation choices over a finite decision horizon. The second approach uses stochastic dynamic programming to make adaptation decisions, and thanks to performing part of the computations required to make those decisions off-line, it achieves a speedup of an order of magnitude over the first solution approach without compromising optimality. A third solution approach makes adaptation decisions based on repertoires of adaptation strategies— predefined compositions of adaptation tactics. This approach is more scalable than the other two because the solution space is smaller, allowing an adaptive system to reap some of the benefits of proactive latency-aware adaptation even if the number of ways in which it could adapt is too large for the other approaches to consider all these possibilities. We evaluate the approach using two different classes of systems with different adaptation goals, and different repertoires of adaptation strategies. One of them is a web system, with the adaptation goal of utility maximization. The other is a cyberphysical system operating in a hostile environment. In that system, self-adaptation must not only maximize the reward gained, but also keep the probability of surviving a mission above a threshold. In both cases, our results show that proactive latency-aware adaptation improves the effectiveness of self-adaptation with respect to reactive time-agnostic adaptation.

Engineering contemporary distributed software applications is a challenging task due to the dynamic operating conditions in which these systems have to function. Examples are dynamic availability of resources, errors that are difficult to predict, and changing user requirements. These dynamics can affect a number of quality concerns of a system, such as robustness, openness, and performance. The challenges of engineering software systems with such dynamics have motivated the need for self-adaptation. Self-adaptation is based on the principle of separation of concerns, distinguishing two well defined systems: a managed system that deals with domain specific concerns and a managing system that deals with particular quality concerns of the managed system through adaptation with a feedback loop. State of the art in self- adaptation advocates the use of formal methods to specify and verify the system's behavior in order to provide evidence that the system's goals are satisfied. However, little work has been done on the consolidation of design knowledge to model and verify self-adaptation behaviors. To support designers, this thesis contributes with a set of formally specified templates for the specification and verification of self-adaptive behaviors of a family of distributed self-adaptive systems. The templates are based on the MAPE-K reference model (Monitor-Analyze-Plan-Execute plus Knowledge). The templates comprise: (1) behavior specification patterns for modeling the different MAPE components of a feedback loop, and (2) property specification patterns that support verification of the correctness of the adaptation behaviors. The target domain are distributed applications in which self-adaptation is used for managing resources for robustness and openness requirements. The templates are derived from expertise with developing several self-adaptive systems, including a collaborative mobile learning application in which we have applied self-adaptation to make the system robust to degrading GPS accuracy, and a robotic system in which we apply self-adaptation to support different types of openness requirements. We demonstrate the reusability of the templates in a number of case studies. / AMULETS

No description available.

The scale of computing systems has extensively grown over the past few decades in order to satisfy emerging business requirements. As a result of this evolution, the complexity of these systems has increased significantly, which has led to many difficulties in managing and administering them. The solution to this problem is to build systems that are capable of managing themselves, given high-level objectives. This vision is also known as Autonomic Computing. A self-managing system is governed by a closed control loop, which is responsible for dynamically monitoring the underlying system, analyzing the observed situation, planning the recovering actions, and executing the plan to maintain the system equilibrium. The realization of such systems poses several developmental and operational challenges, including: developing their architecture, constructing the control loop, and creating services that enable dynamic adaptation behavior. Software frameworks are effective in addressing these challenges: they can simplify the development of such systems by reducing design and implementation efforts, and they provide runtime services for supporting self-managing behavior. This dissertation presents a novel software framework, called StarMX, for developing adaptive and self-managing Java-based systems. It is a generic configurable framework based on standards and well-established principles, and provides the required features and facilities for the development of such systems. It extensively supports Java Management Extensions (JMX) and is capable of integrating with different policy engines. This allows the developer to incorporate and use these techniques in the design of a control loop in a flexible manner. The control loop is created as a chain of entities, called processes, such that each process represents one or more functions of the loop (monitoring, analyzing, planning, and executing). A process is implemented by either a policy language or the Java language. At runtime, the framework invokes the chain of processes in the control loop, providing each one with the required set of objects for monitoring and effecting. An open source Java-based Voice over IP system, called CC2, is selected as the case study used in a set of experiments that aim to capture a solid understanding of the framework suitability for developing adaptive systems and to improve its feature set. The experiments are also used to evaluate the performance overhead incurred by the framework at runtime. The performance analysis results show the execution time spent in different components, including the framework itself, the policy engine, and the sensors/effectors. The results also reveal that the time spent in the framework is negligible, and it has no considerable impact on the system's overall performance.

The scale of computing systems has extensively grown over the past few decades in order to satisfy emerging business requirements. As a result of this evolution, the complexity of these systems has increased significantly, which has led to many difficulties in managing and administering them. The solution to this problem is to build systems that are capable of managing themselves, given high-level objectives. This vision is also known as Autonomic Computing. A self-managing system is governed by a closed control loop, which is responsible for dynamically monitoring the underlying system, analyzing the observed situation, planning the recovering actions, and executing the plan to maintain the system equilibrium. The realization of such systems poses several developmental and operational challenges, including: developing their architecture, constructing the control loop, and creating services that enable dynamic adaptation behavior. Software frameworks are effective in addressing these challenges: they can simplify the development of such systems by reducing design and implementation efforts, and they provide runtime services for supporting self-managing behavior. This dissertation presents a novel software framework, called StarMX, for developing adaptive and self-managing Java-based systems. It is a generic configurable framework based on standards and well-established principles, and provides the required features and facilities for the development of such systems. It extensively supports Java Management Extensions (JMX) and is capable of integrating with different policy engines. This allows the developer to incorporate and use these techniques in the design of a control loop in a flexible manner. The control loop is created as a chain of entities, called processes, such that each process represents one or more functions of the loop (monitoring, analyzing, planning, and executing). A process is implemented by either a policy language or the Java language. At runtime, the framework invokes the chain of processes in the control loop, providing each one with the required set of objects for monitoring and effecting. An open source Java-based Voice over IP system, called CC2, is selected as the case study used in a set of experiments that aim to capture a solid understanding of the framework suitability for developing adaptive systems and to improve its feature set. The experiments are also used to evaluate the performance overhead incurred by the framework at runtime. The performance analysis results show the execution time spent in different components, including the framework itself, the policy engine, and the sensors/effectors. The results also reveal that the time spent in the framework is negligible, and it has no considerable impact on the system's overall performance.

There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software's operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a self-adaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.