13 research outputs found

    Requirements Problem and Solution Concepts for Adaptive Systems Engineering, and their Relationship to Mathematical Optimisation, Decision Analysis, and Expected Utility Theory

    Full text link
    Requirements Engineering (RE) focuses on eliciting, modelling, and analyzing the requirements and environment of a system-to-be in order to design its specification. The design of the specification, usually called the Requirements Problem (RP), is a complex problem solving task, as it involves, for each new system-to-be, the discovery and exploration of, and decision making in, new and ill-defined problem and solution spaces. The default RP in RE is to design a specification of the system-to-be which (i) is consistent with given requirements and conditions of its environment, and (ii) together with environment conditions satisfies requirements. This paper (i) shows that the Requirements Problem for Adaptive Systems (RPAS) is different from, and is not a subclass of the default RP, (ii) gives a formal definition of RPAS, and (iii) discusses implications for future research

    Self-adaptive Software Modeling Based on Contextual Requirements

    Get PDF
    The ability of self-adaptive software in responding to change is determined by contextual requirements, i.e. a requirement in capturing relevant context-atributes and modeling behavior for system adaptation. However, in most cases, modeling for self-adaptive software is does not take into consider the requirements evolution based on contextual requirements. This paper introduces an approach through requirements modeling languages directed to adaptation patterns to support requirements evolution. The model is prepared through contextual requirements approach that is integrated into MAPE-K (monitor, anayze, plan, execute - knowledge) patterns in goal-oriented requirements engineering. As an evaluation, the adaptation process is modeled for cleaner robot. The experimental results show that the requirements modeling process has been able to direct software into self-adaptive capability and meet the requirements evolution

    Runtime Verification of Self-Adaptive Systems with Changing Requirements

    Full text link
    To accurately make adaptation decisions, a self-adaptive system needs precise means to analyze itself at runtime. To this end, runtime verification can be used in the feedback loop to check that the managed system satisfies its requirements formalized as temporal-logic properties. These requirements, however, may change due to system evolution or uncertainty in the environment, managed system, and requirements themselves. Thus, the properties under investigation by the runtime verification have to be dynamically adapted to represent the changing requirements while preserving the knowledge about requirements satisfaction gathered thus far, all with minimal latency. To address this need, we present a runtime verification approach for self-adaptive systems with changing requirements. Our approach uses property specification patterns to automatically obtain automata with precise semantics that are the basis for runtime verification. The automata can be safely adapted during runtime verification while preserving intermediate verification results to seamlessly reflect requirement changes and enable continuous verification. We evaluate our approach on an Arduino prototype of the Body Sensor Network and the Timescales benchmark. Results show that our approach is over five times faster than the typical approach of redeploying and restarting runtime monitors to reflect requirements changes, while improving the system's trustworthiness by avoiding interruptions of verification.Comment: 18th Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2023

    Model-Based Simulation at Runtime for Self-Adaptive Systems

    Full text link

    STRUKTUR KNOWLEDGE BASE SEBAGAI KOMPONEN PEMBENTUK PERANGKAT LUNAK SELF-ADAPTIVE

    Get PDF
    Suatu sistem terlahir didasari atas target visi dari concern yang digelutinya masing-masing. Dalam perjalanannya, setiap sistem senantiasa bersentuhan dengan kompleksitas dan ketidakpastian didalam lingkungannya. Hal ini berhubungan dengan bagaimana sistem itu hidup, yaitu mampu tumbuh dan terus berkembang. Keberadaan perangkat lunak self-adaptive merupakan jawaban atas persoalan dan tantangan tersebut, suatu perangkat lunak sebagai penggerak utama sistem, dituntut memiliki kemampuan untuk dapat memahami dan bertindak atas apa yang terjadi didalam lingkungannya, termasuk penanganan pertumbuhan pengetahuannya. Dalam kebanyakan kasus, konstruksi struktur pengetahuan biasanya dirancang melalui suatu kekhusuan, sehingga lingkup yang dilayaninya menjadi terbatas. Makalah ini mengusulkan model representasi pengetahuan sebagai jaminan bagi pengelolaan sistem dan kebutuhan adaptasinya, model diformulasikan melalui rule-based systems dengan struktur knowledge base yang lebih generik dan luwes, sehingga mampu menangani pertumbuhan pengetahuan yang merepresentasikan ragam konteks dan perilaku sistem.Kata kunci : self-adaptive software, intelligent systems, knowledge base, rule-based systems

    Engineering Trustworthy Self-Adaptive Software with Dynamic Assurance Cases

    Get PDF
    Building on concepts drawn from control theory, self-adaptive software handles environmental and internal uncertainties by dynamically adjusting its architecture and parameters in response to events such as workload changes and component failures. Self-adaptive software is increasingly expected to meet strict functional and non-functional requirements in applications from areas as diverse as manufacturing, healthcare and finance. To address this need, we introduce a methodology for the systematic ENgineering of TRUstworthy Self-adaptive sofTware (ENTRUST). ENTRUST uses a combination of (1) design-time and runtime modelling and verification, and (2) industry-adopted assurance processes to develop trustworthy self-adaptive software and assurance cases arguing the suitability of the software for its intended application. To evaluate the effectiveness of our methodology, we present a tool-supported instance of ENTRUST and its use to develop proof-of-concept self-adaptive software for embedded and service-based systems from the oceanic monitoring and e-finance domains, respectively. The experimental results show that ENTRUST can be used to engineer self-adaptive software systems in different application domains and to generate dynamic assurance cases for these systems

    Managing software evolution through midleware and policy-based software adaptation framework

    Get PDF
    Software evolution is a process that is needed in order for software to remain useful. Thus, software evolution should be properly planned and controlled to prevent its negative impact from affecting any organization. Software adaptation concept is one of the promising ways to control software evolution. In this approach, software is made adaptable to minimize the impact of change. A lot of researches on software adaptation focus on adaptability of mobile based and network application due to its context sensitivity and quality-of-service requirements. However, there is still lack of work in enterprise system domain with multiple delivery channels, which focus on adaptability of its context environment such as the changes introduced to its devices. Hence, the purpose of this research is to develop a middleware and policy-based, adaptation framework to manage negative effects of software evolution in an enterprise system. The main research focus is on the changes introduced at the device layer. The concept of policy is used to specify adaptations requirements. This research provides a framework called Middleware and Policy-Based Framework to Manage Software Evolution (MiPAF), which can be used to develop adaptive software, allowing parameterized and compositional adaptation. Furthermore, the framework can be used by client-server and web-based application. A policy language called MiPAF Policy Language (MPL) is created to be used with the framework. MiPAF is formally specified using Z Notation and the policy language is described using pseudo code. A tool is provided to assist developers in creating the policy. For evaluation of the framework, a set of runtime components were developed and implemented for Unit Trust System (UTS) Front-end and web-based UTS, two industrial-based case studies. The evaluation result shows that MiPAF excellently fulfil all the evaluation criteria described in this thesis

    RRO Uma Ontologia Sobre o Uso de Requisitos de Software em Tempo de Execução

    Get PDF
    Nos últimos anos, temos assistido um constante aumento de interesse em sistemas de software que são capazes de monitorar seu meio de execução e, se necessário, adaptar seus requisitos para continuar cumprindo seu propósito. Esse tipo de software normalmente consiste em um software base, comumente chamado na literatura de target system, que é responsável por executar a função principal para qual foi desenvolvido; além de um software, interno ou externo, responsável por monitorar o software base, realizar uma análise dos dados coletados para verificar se os requisitos que foram originalmente propostos estão sendo cumpridos e, se necessário, reagir sugerindo adaptações para garantir que o sistema base continue executando suas funções principais de forma satisfatória. Existem na literatura diversos trabalhos que propõem o uso de requisitos em tempo de execução, como sistemas adaptativos ou autônomos. No entanto, dentro desse contexto, a maioria das propostas usam suas próprias linguagens de modelagem e metodologias para representar o que são os requisitos de sistema e como utilizá-los em tempo de execução. Não há, assim, um senso comum no domínio de uso de requisitos em tempo de execução, resultando numa sobrecarga excessiva de termos e construtos. Essa falta de consenso dentro do domínio apresentado e os problemas de comunicação gerados pela falta de um vocabulário formal e bem fundamentado foram as motivações principais para que fosse realizado um estudo sistemático sobre as diversas metodologias existentes na literatura de requisitos em tempo de execução e através do conhecimento adquirido fosse construída a RRO (Runtime Requirements Ontology), uma ontologia de referência de domínio sobre o uso de requisitos em tempo de execução. RRO foi construída através da metodologia de construção de ontologias SABiO e é fundamentada em UFO com objetivo atuar como uma representação formal do conhecimento dentro do domínio de requisitos em tempo de execução, fornecendo, desta maneira, uma descrição precisa de todas as entidades principais que compõem o domínio e estabelecendo um vocabulário comum para ser utilizado por engenheiros de software e stakeholders
    corecore