lnu.sePublications
Change search
Refine search result
1 - 20 of 20
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Abbas, Nadeem
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Andersson, Jesper
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Rigorous architectural reasoning for self-adaptive software systems2016In: Proceedings: First Workshop on Qualitative Reasoning abut Software Architectures, QRASA 2016 / [ed] Lisa O'Conner, IEEE, 2016, p. 11-18Conference paper (Refereed)
    Abstract [en]

    Designing a software architecture requires architectural reasoning, i.e., activities that translate requirements to an architecture solution. Architectural reasoning is particularly challenging in the design of product-lines of self-adaptive systems, which involve variability both at development time and runtime. In previous work we developed an extended Architectural Reasoning Framework (eARF) to address this challenge. However, evaluation of the eARF showed that the framework lacked support for rigorous reasoning, ensuring that the design complies to the requirements. In this paper, we introduce an analytical framework that enhances eARF with such support. The framework defines a set of artifacts and a series of activities. Artifacts include templates to specify domain quality attribute scenarios, concrete models, and properties. The activities support architects with transforming requirement scenarios to architecture models that comply to required properties. Our focus in this paper is on architectural reasoning support for a single product instance. We illustrate the benefits of the approach by applying it to an example client-server system, and outline challenges for future work. © 2016 IEEE.

  • 2.
    Algabroun, Hatem
    et al.
    Linnaeus University, Faculty of Technology, Department of Mechanical Engineering.
    Iftikhar, Muhammad Usman
    Al-Najjar, Basim
    Linnaeus University, Faculty of Technology, Department of Mechanical Engineering.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Maintenance 4.0 Framework using Self: Adaptive Software Architecture2018In: Journal of Maintenance Engineering, Vol. 2, p. 280-293Article in journal (Refereed)
    Abstract [en]

    With the recent advances of manufacturing technologies, referred to as Industry 4.0, maintenance approaches have to be developed to fulfill the new de-mands. The technological complexity associated to Industry 4.0 makes designing maintenance solutions particularly challenging. This paper proposes a novel maintenance framework leveraging principles from self-adaptation and software architecture. The framework was tested in an operational scenario where a bearing condition in an electrical motor needs to be managed, the results showed a proper operation. As a conclusion, the proposed framework could be used to develop maintenance systems for Industry 4.0.

  • 3.
    Algabroun, Hatem
    et al.
    Linnaeus University, Faculty of Technology, Department of Mechanical Engineering.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Al-Najjar, Basim
    Linnaeus University, Faculty of Technology, Department of Mechanical Engineering.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM). Catholic University of Leuven, Belgium.
    Maintenance 4.0 Framework Using Self-Adaptive Software Architecture2017In: Proceedings of 2nd International Conference on Maintenance Engineering, IncoME-II 2017.The University of Manchester, UK, The University of Manchester, UK , 2017, , p. 299-309Conference paper (Refereed)
    Abstract [en]

    With the recent advances of manufacturing technologies, referred to as Industry 4.0, maintenance approaches have to be developed to fulfill the new de-mands. The technological complexity associated to Industry 4.0 makes designing maintenance solutions particularly challenging. This paper proposes a novel maintenance framework leveraging principles from self-adaptation and software architecture. The framework was tested in an operational scenario where a bearing condition in an electrical motor needs to be managed, the results showed a proper operation. As a conclusion, the proposed framework could be used to develop maintenance systems for Industry 4.0.

  • 4.
    Calinescu, Radu
    et al.
    University of York, UK.
    Weyns, Danny
    Katholieke Universiteit Leuven.
    Gerasimou, Simos
    University of York, UK.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Habli, Ibrahim
    University of York, UK.
    Kelly, Tim
    University of York, UK.
    Engineering Trustworthy Self-Adaptive Software with Dynamic Assurance Cases2018In: IEEE Transactions on Software Engineering, ISSN 0098-5589, E-ISSN 1939-3520, Vol. 44, no 11, p. 1039-1069Article in journal (Refereed)
    Abstract [en]

    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.

  • 5.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM), Department of Computer Science. Faculty of Engineering Science, Department of Computer Science, KU Leuven, Belgium.
    A Model-Based Approach to Engineer Self-Adaptive Systems with Guarantees2017Doctoral thesis, monograph (Other academic)
    Abstract [en]

    Modern software systems are increasingly characterized by uncertainties in the operating context and user requirements. These uncertainties are difficult to predict at design time. Achieving the quality goals of such systems depends on the ability of the software to deal with these uncertainties at runtime. A self-adaptive system employs a feedback loop to continuously monitor and adapt itself to achieve particular quality goals (i.e., adaptation goals) regardless of uncertainties. Current research applies formal techniques to provide guarantees for adaptation goals, typically using exhaustive verification techniques. Although these techniques offer strong guarantees for the goals, they suffer from well-known state explosion problem. In this thesis, we take a broader perspective and focus on two types of guarantees: (1) functional correctness of the feedback loop, and (2) guaranteeing the adaptation goals in an efficient manner. To that end, we present ActivFORMS (Active FORmal Models for Self-adaptation), a formally founded model-driven approach for engineering self-adaptive systems with guarantees. ActivFORMS achieves functional correctness by direct execution of formally verified models of the feedback loop using a reusable virtual machine. To efficiently provide guarantees for the adaptation goals with a required level of confidence, ActivFORMS applies statistical model checking at runtime. ActivFORMS supports on the fly changes of adaptation goals and updates of the verified feedback loop models that meet the changed goals. To demonstrate the applicability and effectiveness of the approach, we applied ActivFORMS in several domains: warehouse transportation, oceanic surveillance, tele assistance, and IoT building security monitoring.

  • 6.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Lundberg, Jonas
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of Computer Science. Katholieke Univ Leuven, Leuven, Belgium.
    A Model Interpreter for Timed Automata2016In: Leveraging Applications of Formal Methods, Verification and Validation: Foundational Techniques, PT I, Springer, 2016, p. 243-258Conference paper (Refereed)
    Abstract [en]

    In the model-centric approach to model-driven development, the models used are sufficiently detailed to be executed. Being able to execute the model directly, without any intermediate model-to-code translation, has a number of advantages. The model is always up-to-date and runtime updates of the model are possible. This paper presents a model interpreter for timed automata, a formalism often used for modeling and verification of real-time systems. The model interpreter supports real-time system features like simultaneous execution, system wide signals, a ticking clock, and time constraints. Many existing formal representations can be verified, and many existing DSMLs can be executed. It is the combination of being both verifiable and executable that makes our approach rather unique.

  • 7.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Ramachandran, Gowri Sankar
    KU Leuven, Belgium.
    Bollansée, Pablo
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM). KU Leuven, Belgium.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM). KU Leuven, Belgium.
    Hughes, Danny
    KU Leuven, Belgium.
    DeltaIoT: A Self-Adaptive Internet of Things Exemplar2017In: Proceedings - 2017 IEEE/ACM 12th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2017, IEEE, 2017, p. 76-82Conference paper (Refereed)
    Abstract [en]

    Internet of Things (IoT) consists of networked tiny embedded computers (motes) that are capable of monitoring and controlling the physical world. Examples range from building security monitoring to smart factories. A central problem of IoT is minimising the energy consumption of the motes, while guaranteeing high packet delivery performance, regardless of uncertainties such as sudden changes in traffic load and communication interference. Traditionally, to deal with uncertainties the network settings are either hand-tuned or over-provisioned, resulting in continuous network maintenance or inefficiencies. Enhancing the IoT network with self-adaptation can automate these tasks. This paper presents DeltaIoT, an exemplar that enables researchers to evaluate and compare new methods, techniques and tools for self-adaptation in IoT. DeltaIoT is the first exemplar for research on self-adaptation that provides both a simulator for offline experimentation and a physical setup that can be accessed remotely for real-world experimentation. © 2017 IEEE.

  • 8.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Weyns, Danny
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    A Case Study on Formal Verification of Self-Adaptive Behaviors in a Decentralized System2012In: Electronic Proceedings in Theoretical Computer Science / [ed] Natallia Kokash and António Ravara, 2012, Vol. 91, no 91, p. 45-62Conference paper (Refereed)
    Abstract [en]

    Self-adaptation is a promising approach to manage the complexity of modern software systems. A self-adaptive system is able to adapt autonomously to internal dynamics and changing conditions in the environment to achieve particular quality goals. Our particular interest is in decentralized selfadaptive systems, in which central control of adaptation is not an option. One important challenge in self-adaptive systems, in particular those with decentralized control of adaptation, is to provide guarantees about the intended runtime qualities. In this paper, we present a case study in which we use model checking to verify behavioral properties of a decentralized self-adaptive system. Concretely, we contribute with a formalized architecture model of a decentralized traffic monitoring system and prove a number of self-adaptation properties for flexibility and robustness. To model the main processes in the system we use timed automata, and for the specification of the required properties we use timed computation tree logic. We use the Uppaal tool to specify the system and verify the flexibility and robustness properties.

  • 9.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of Computer Science. Katholieke University Leuven, Belgium.
    ActivFORMS: A Runtime Environment for Architecture-Based Adaptation with Guarantees2017In: 2017 IEEE INTERNATIONAL CONFERENCE ON SOFTWARE ARCHITECTURE WORKSHOPS (ICSAW), IEEE, 2017, p. 278-281Conference paper (Refereed)
    Abstract [en]

    Modern software systems are exposed to various types of uncertainties, such as dynamics in the available resources that are difficult to predict and goals that may change during operation. Self-adaptation equips a software system with a feedback loop that collects additional knowledge at runtime, monitors the system and adapts it when necessary to maintain its quality goals, regardless of uncertainties. One challenging problem of self-adaptation is to provide guarantees for the goals that are subject of adaptation. In this paper, we present the ActivFORMS runtime environment to realise self- adaptation with guarantees. With ActivFORMS designers model and verify a feedback loop. The verified models can directly be deployed on top of a virtual machine that executes the models to realise adaption. The approach avoids coding of the models, which is an error-prone task. The runtime environment visualises the executing models, the state of the goals, and it supports on the fly updates of the models and goals. We illustrate the approach with an adaptation scenario of an IoT building security example.

  • 10.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science. Linnaeus University.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    ActivFORMS: Active Formal Models for Self-adaptation2014In: Proceedings of the 9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, ACM Press, 2014, p. 125-134Conference paper (Refereed)
    Abstract [en]

    Self-adaptation enables a software system to deal autonomously with uncertainties, such as dynamic operating conditions that are difficult to predict or changing goals. A common approach to realize self-adaptation is with a MAPE-K feedback loop that consists of four adaptation components: Monitor, Analyze, Plan, and Execute. These components share Knowledge models of the managed system, its goals and environment. To provide guarantees of the adaptation goals, state of the art approaches propose using formal models of the knowledge. However, less attention is given to the formalization of the adaptation components themselves, which is important to provide guarantees of correctness of the adaptation behavior (e.g., does the execute component execute the plan correctly?). We propose Active FORmal Models for Self-adaptation (ActivFORMS) that uses an integrated formal model of the adaptation components and knowledge models. The formal model is directly executed by a virtual machine to realize adaptation, hence active model. The contributions of ActivFORMS are: (1) the approach assures that the adaptation goals that are verified offline are guaranteed at runtime, and (2) it supports dynamic adaptation of the active model to support changing goals. We show how we have applied ActivFORMS for a small-scale robotic system

  • 11.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science. Linnaeus University.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Assuring System Goals Under Uncertainty with Active Formal Models of Self-adaptation2014In: Companion Proceedings of the 36th International Conference on Software Engineering, ACM/IEEE , 2014, p. 604-605Conference paper (Refereed)
    Abstract [en]

    Designing software systems with uncertainties, such as incomplete knowledge about changing system goals, is challenging. One approach to handle uncertainties is self-adaptation, where a system consists of a managed system and a managing system that realizes a feedback loop. The promise of self-adaptation is to enable a system to adapt itself realizing the system goals, regarding uncertainties. To realize this promise it is critical to provide assurances for the self-adaptive behaviours. Several approaches have been proposed that exploit formal methods to provide these assurances. However, an integrated approach that combines: (1) seamless integration of offline and online verification (to deal with inherent limitations of verification), with (2) support for runtime evolution of the system (to deal with new or changing goals) is lacking. In this paper, we outline a new approach named Active FORmal Models of Self-adaptation (ActivFORMS) that aims to deal with these challenges. In ActivFORMS, the formal models of the managing system are directly deployed and executed to realize self-adaptation, guaranteeing the verified properties. Having the formal models readily available at runtime paves the way for: (1) incremental verification during system execution, and (2) runtime evolution of the self-adaptive system. Experiences with a robotic system show promising results.

  • 12.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Weyns, Danny
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Formal Verification of Self-Adaptive Behaviors in Decentralized Systems with Uppaal: An Initial Study2012Report (Other academic)
  • 13.
    Iftikhar, Muhammad Usman
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Weyns, Danny
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Model Checking of Self-Adaptive Behaviors in a Multi-Agent System for Traffic Monitoring2012In: Proceedings of European Workshop on Multi-Agent Systems EUMAS 2012, University College Dublin , 2012Conference paper (Refereed)
  • 14.
    Shevtsov, Stepan
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    SimCA vs ActivFORMS: comparing control- and architecture-based adaptation on the TAS exemplar2015In: Proceedings of the 1st International Workshop on Control Theory for Software Engineering, New York, NY, USA: ACM Press, 2015, p. 1-8Conference paper (Refereed)
    Abstract [en]

    Today customers require software systems to provide particular levels of qualities, while operating under dynamically changing conditions. These requirements can be met with different self-adaptation approaches. Recently, we developed two approaches that are different in nature - control theory-based SimCA and architecture-based ActivFORMS - to endow software systems with self-adaptation, providing guarantees on desired behavior. However, it is unclear which of the two approaches should be used in different adaptation scenarios and how effective they are in comparison to each other. In this paper, we apply SimCA and ActivFORMS to the Tele Assistance System (TAS) exemplar and compare obtained results, demonstrating the difference in achieved qualities and formal guarantees.

  • 15.
    Van der Donckt, M. Jeroen
    et al.
    Katholieke Univ Leuven, Belgium.
    Weyns, Danny
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM). Katholieke Univ Leuven, Belgium.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM). Katholieke Univ Leuven, Belgium.
    Singh, Ritesh Kumar
    Katholieke Univ Leuven, Belgium.
    Cost-Benefit Analysis at Runtime for Self-adaptive Systems Applied to an Internet of Things Application2018In: Proceedings of the 13th International Conference on Evaluation of Novel Approaches to Software Engineering / [ed] Damiani, E Spanoudakis, G Maciaszek, L, SciTePress, 2018, p. 478-490Conference paper (Refereed)
    Abstract [en]

    Ensuring the qualities of modern software systems, such as the Internet of Things, is challenging due to various uncertainties, such as dynamics in availability of resources or changes in the environment. Self-adaptation is an established approach to deal with such uncertainties. Self-adaptation equips a software system with a feedback loop that tracks changes and adapts the system accordingly to ensure its quality goals. Current research in this area has primarily focussed on the benefits that self-adaptation can offer. However, realising adaption can also incur costs. Ignoring these costs may invalidate the expected benefits. We start with demonstrating that the costs for adaptation can be significant. To that end, we apply a state-of-the-art approach for self-adaptation to an Internet of Things (IoT) application. We then present CB@R (Cost-Benefit analysis @ Runtime), a novel model-based approach for runtime decision-making in self-adaptive systems. CB@R is inspired by the Cost-Benefit Analysis Method (CBAM), which is an established approach for analysing costs and benefits of architectural decisions. We evaluate CB@R for a real world deployed IoT application and compare it with the conservative approach applied in practice and a state-of-the-art self-adaptation approach.

  • 16.
    Weyns, Danny
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science. Katholieke Univ Leuven, Belgium.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Model-based Simulation at Runtime for Self-adaptive Systems2016In: 2016 IEEE International Conference on Autonomic Computing (ICAC), IEEE, 2016, p. 364-373Conference paper (Refereed)
    Abstract [en]

    Modern software systems are subject to uncertainties, such as dynamics in the availability of resources or changes of system goals. Self-adaptation enables a system to reason about runtime models to adapt itself and realises its goals under uncertainties. Our focus is on providing guarantees for adaption goals. A prominent approach to provide such guarantees is automated verification of a stochastic model that encodes up-to-date knowledge of the system and relevant qualities. The verification results allow selecting an adaption option that satisfies the goals. There are two issues with this state of the art approach: i) changing goals at runtime (a challenging type of uncertainty) is difficult, and ii) exhaustive verification suffers from the state space explosion problem. In this paper, we propose a novel modular approach for decision making in self-adaptive systems that combines distinct models for each relevant quality with runtime simulation of the models. Distinct models support on the fly changes of goals. Simulation enables efficient decision making to select an adaptation option that satisfies the system goals. The tradeoff is that simulation results can only provide guarantees with a certain level of accuracy. We demonstrate the benefits and tradeoffs of the approach for a service-based telecare system.

  • 17.
    Weyns, Danny
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Gil de la Iglesia, Didac
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Ahmad, Tanvir
    A survey of formal methods in self-adaptive systems2012In: ACM International Conference Proceeding Series, ACM Press, 2012, p. 67-79Conference paper (Refereed)
    Abstract [en]

    One major challenge in self-adaptive systems is to assure the required quality properties. Formal methods provide the means torigorously specify and reason about the behaviors of self-adaptivesystems, both at design time and runtime. To the best of our knowledge, no systematic study has been performed on the use of formalmethods in self-adaptive systems. As a result, there is no clearview on what methods have been used to verify self-adaptive systems, and what support these methods offer to software developers. As such insight is important for researchers and engineers,we performed a systematic literature review covering 12 main software engineering venues and 4 journals, resulting in 75 papers usedfor data collection. The study shows that the attention for selfadaptive software systems is gradually increasing, but the numberof studies that employ formal methods remains low. The main focus of formalization is on modeling and reasoning. Model checking and theorem proving have gained limited attention. The mainconcerns of interest in formalization of self-adaptation are effi-ciency/performance and reliability. Important adaptation concerns,such as security and scalability, are hardly considered. To verify theconcerns of interest, a set of new properties are defined, such as interference freedom, responsiveness, mismatch, and loss-tolerance.A relevant part of the studies use formal methods at runtime, butthe use is limited to modeling and analysis. Formal methods can beapplied to other runtime activities of self-adaptation, and the

  • 18.
    Weyns, Danny
    et al.
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM). Katholieke Universiteit Leuven, Belgium.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of computer science and media technology (CM).
    Hughes, Danny
    Katholieke Universiteit Leuven, Belgium;VersaSense, Belgium.
    Matthys, Nelson
    VersaSense, Belgium.
    Applying architecture-based adaptation to automate the management of internet-of-things2018In: 12th European Conference on Software Architecture, ECSA 2018 / [ed] Carlos E. Cuesta, David Garlan Jennifer Pérez, Springer, 2018, p. 449-467Conference paper (Refereed)
    Abstract [en]

    Architecture-based adaptation equips a software-intensive system with a feedback loop that enables the system to adapt itself at runtime to changes to maintain its required quality goals. To guarantee the required goals, existing adaptation approaches apply exhaustive verification techniques at runtime. However these approaches are restricted to small-scale settings, which often limits their applicability in practice. To tackle this problem, we introduce an innovative architecture-based adaptation approach to solve a concrete practical problem of VersaSense: automating the management of Internet-of-Things (IoT). The approach, called MARTAS, equips a software system with a feedback loop that employs Models At Run Time and Statistical techniques to reason about the system and adapt it to ensure the required goals. We apply MARTAS to a building security case system, which is a representative IoT system deployed by VersaSense. The application comprises a set of IoT devices that communicate sensor data over a time synchronized smart mess network to a central monitoring facility. We demonstrate how MARTAS outperforms a conservative approach that is typically applied in practice and a state-of-the-art adaptation approach for different quality goals, and we report lessons learned from this industrial case. © Springer Nature Switzerland AG 2018.

  • 19.
    Weyns, Danny
    et al.
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Malek, Sam
    Andersson, Jesper
    Linnaeus University, Faculty of Science and Engineering, School of Computer Science, Physics and Mathematics.
    Claims and Supporting Evidence for Self-Adaptive Systems: A Literature Study2012In: ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems, IEEE, 2012, p. 89-98Conference paper (Refereed)
    Abstract [en]

    Despite the vast body of work on self-adaption, no systematic study has been performed on the claims associated with self-adaptation and the evidence that exists for these claims. As such an insight is crucial for researchers and engineers, we performed a literature study of the research results from SEAMS since 2006 and the associated Dagstuhl seminar in 2008. The study shows that the primary claims of self-adaptation are improved flexibility, reliability, and performance of the system. On the other hand, the tradeoffs implied by self-adaptation have not received much attention. Evidence is obtained from basic examples, or simply lacking. Few systematic empirical studies have been performed, and no industrial evidence is reported. From the study, we offer the following recommendations to move the field forward: to improve evaluation, researchers should make their assessment methods, tools and data publicly available; to deal with poor discussion of limitations, conferences/workshops should require an explicit section on limitations in engineering papers; to improve poor treatment of tradeoffs, this aspect should be an explicit subject of reviews; and finally, to enhance industrial validation, the best academy-industry efforts could be formally recognized by the community.

  • 20.
    Weyns, Danny
    et al.
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Iftikhar, Muhammad Usman
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Söderlund, Joakim
    Linnaeus University, Faculty of Technology, Department of Computer Science.
    Do External Feedback Loops Improve the Design of Self-Adaptive Systems?: A Controlled Experiment2013In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, New York: IEEE Press, 2013, p. 3-12Conference paper (Refereed)
    Abstract [en]

    Providing high-quality software in the face of uncertainties, such as dealing with new user needs, changing availability of resources, and faults that are difficult to predict, raises fundamental challenges to software engineers. These challenges have motivated the need for self-adaptive systems. One of the primary claimed benefits of self-adaptation is that a design with external feedback loops provide a more effective engineering solution for self-adaptation compared to a design with internal mechanisms. While many efforts indicate the validity of this claim, to the best of our knowledge, no controlled experiments have been performed that provide scientifically founded evidence for it. Such experiments are crucial for researchers and engineers to underpin their claims and improve research. In this paper, we report the results of a controlled experiment performed with 24 final-year students of a Master in Software Engineering program in which designs based on external feedback loops are compared with designs based on internal mechanisms. The results show that applying external feedback loops can reduce control flow complexity and fault density, and improve productivity. We found no evidence for a reduction of activity complexity.

1 - 20 of 20
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • harvard1
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf