Advertisement

Scen@rist: an approach for verifying self-adaptive systems using runtime scenarios

  • Rômulo Gadelha
  • Lucas Vieira
  • Davi Monteiro
  • Felipe Vidal
  • Paulo Henrique MaiaEmail author
Article
  • 18 Downloads

Abstract

Traditional runtime quantitative verification approaches for self-adaptive systems usually rely on the use of state-transition models to describe the system behaviour and check property violation at runtime. More recently, some approaches have advocated the use of scenarios as a strategy for representing both the normal and adaptive system behaviour. However, the use of scenarios as a runtime entity that drives the system adaptation is still a challenge since many research issues regarding the use of scenarios to support analysis for enabling self-adjustment at runtime in software systems remain open. The aim of this paper is twofold. Firstly, we investigate the use of scenario-based approaches in self-adaptive systems via a systematic mapping study. Secondly, we introduce Scen@rist, an approach that uses scenarios as runtime entities for verifying self-adaptive systems. The approach consists of monitoring a running self-adaptive system, annotating its scenario-based behaviour specification with the probability of transitions between scenarios, and then verifying whether a set of reachability properties hold. This is performed by translating the scenario-based models and properties in their probabilistic state-based counterparts and applying a model checking technique. The applicability of the proposed tool has been demonstrated by two self-adaptive service-based systems taken from the literature.

Keywords

Self-adaptive systems Runtime scenarios Runtime verification Systematic mapping study Model checking Message sequence chart 

Notes

Funding information

This work was financed in part by the Coordination for the Improvement of Higher Education Personnel - Brazil (CAPES) - Finance Code 001. This work was also partially supported by CNPq/Brazil under grant Universal 438783/2018-2 and by Science Foundation Ireland grant 13/RC/2094 and co-funded under the European Regional Development Fund through the Southern & Eastern Regional Operational Programme to Lero - the Irish Software Research Centre.10

References

  1. Abushark, Y., Thangarajah, J., Harland, J., Miller, T. (2017). A framework for automatically ensuring the conformance of agent designs. Journal of Systems and Software, 131(C), 266–310.CrossRefGoogle Scholar
  2. Ali, N., Martínez-Martínez, A., Ayuso-Pérez, L., Espinoza, A. (2017). Self-adaptive quality requirement elicitation process for legacy systems: a case study in healthcare. In Proceedings of the symposium on applied computing, SAC ’17 (pp. 1102–1107). New York: ACM.Google Scholar
  3. Amyot, D., & Eberlein, A. (2003). An evaluation of scenario notations and construction approaches for telecommunication systems development. Telecommunication Systems, 24(1), 61–94.CrossRefGoogle Scholar
  4. Andersson, J., Baresi, L., Bencomo, N., de Lemos, R., Gorla, A., Inverardi, P., Vogel, T. (2013). Software engineering processes for self-adaptive systems. In de Lemos, R., Giese, H., Müller, H.A., Shaw, M. (Eds.) Software engineering for self-adaptive systems II: international seminar, dagstuhl castle, germany, october 24-29, 2010 Revised Selected and Invited Papers (pp. 51–75). Berlin: Springer.CrossRefGoogle Scholar
  5. André, P., Rivière, N., Waeselynck, H. (2017). A toolset for mobile systems testing. In Barkaoui, K., Boucheneb, H., Mili, A., Tahar, S. (Eds.) Verification and Evaluation of Computer and Communication Systems: 11th International Conference, VECoS 2017, Montreal, QC, Canada, August 24–25, 2017, Proceedings (pp. 124–138). Cham: Springer International Publishing.Google Scholar
  6. Aniculaesei, A., Grieser, J., Rausch, A., Rehfeldt, K., Warnecke, T. (2018). Towards a holistic software systems engineering approach for dependable autonomous systems. In Proceedings of the 1st international workshop on software engineering for AI in autonomous systems, SEFAIS ’18 (pp. 23–30). New York : ACM.Google Scholar
  7. Arcaini, P., Riccobene, E., Scandurra, P. (2017). Formal design and verification of self-adaptive systems with decentralized control. ACM Trans Auton Adapt Syst, 11 (4), 25:1–25:35.CrossRefGoogle Scholar
  8. Atir, Y., & Harel, D. (2007). Using lscs for scenario authoring in tactical simulators. In Proceedings of the 2007 summer computer simulation conference, society for computer simulation international, San Diego, CA, USA, SCSC ’07, pp. 437–442.Google Scholar
  9. Barbosa, D.M., de Moura Lima, R.G., Maia, P.HM., Junior, E.C. (2017). Lotus@runtime: a tool for runtime monitoring and verification of self-adaptive systems. In Proceedings of the 12th international symposium on software engineering for adaptive and self-managing systems, SEAMS ’17 (pp. 24–30). Piscataway: IEEE Press.Google Scholar
  10. Baresi, L., Bianculli, D., Ghezzi, C., Guinea, S., Spoletini, P. (2007). Validation of web service compositions. IET Software, 1(6), 219–232.CrossRefGoogle Scholar
  11. Bass, L., Clements, P., Kazman, R. (2003). Software architecture in practice, 2nd edn. Boston: Addison-Wesley Longman Publishing Co., Inc.Google Scholar
  12. Bencomo, N., Bennaceur, A., Grace, P., Blair, G., Issarny, V. (2013). The role of models@run.time in supporting on-the-fly interoperability. Computing, 95(3), 167–190.CrossRefGoogle Scholar
  13. Berkman-Chardon, A., Harel, D., Goel, Y., Marelly, R., Szekely, S., Weiss, G. (2016). Scenario-based programming for mobile applications. In: 2016 IEEE/ACM international conference on mobile software engineering and systems (MOBILESoft), pp 161–172.Google Scholar
  14. Blair, G., Bencomo, N., France, R. B. (2009). Models@ run.time. Computer, 42(10), 22–27.CrossRefGoogle Scholar
  15. Braberman, V., D’Ippolito, N., Kramer, J., Sykes, D., Uchitel, S. (2015). Morph: a reference architecture for configuration and behaviour self-adaptation. In Proceedings of the 1st international workshop on control theory for software engineering. CTSE 2015 (pp. 9–16). New York: ACM.Google Scholar
  16. Brugali, D., Capilla, R., Mirandola, R., Trubiani, C. (2018). Model-based development of qos-aware reconfigurable autonomous robotic systems. In 2018 2nd IEEE international conference on robotic computing (IRC), (Vol. 00 pp. 129–136).Google Scholar
  17. Buhr, R.J.A, & Casselman, RS. (1996). Use case maps for object-oriented systems. Upper Saddle River: Prentice-Hall, Inc.zbMATHGoogle Scholar
  18. Calinescu, R., Ghezzi, C., Kwiatkowska, M., Mirandola, R. (2012). Self-adaptive software needs quantitative verification at runtime. Communications of the ACM, 55 (9), 69–77.CrossRefGoogle Scholar
  19. Calinescu, R., Johnson, K., Rafiq, Y. (2013). Developing self-verifying service-based systems. In: 2013 28th IEEE/ACM international conference on automated software engineering (ASE), pp 734–737.Google Scholar
  20. Calinescu, R., Gerasimou, S., Johnson, K., Paterson, C. (2017). Using runtime quantitative verification to provide assurance evidence for self-adaptive software. In de lemos, R., Garlan, D., Ghezzi, C., Giese, H. (Eds.) Software engineering for self-adaptive systems III. Assurances (pp. 223–248). Cham: Springer International Publishing.Google Scholar
  21. Cámara, J., Garlan, D., Schmerl, B. (2017). Synthesis and quantitative verification of tradeoff spaces for families of software systems. In Lopes, A, & de Lemos, R (Eds.) Software architecture (pp. 3–21). Cham: Springer International Publishing.Google Scholar
  22. Caporuscio, M., Di Marco, A., Inverardi, P. (2007). Model-based system reconfiguration for dynamic performance management. Journal of Systems and Software, 80(4), 455–473.CrossRefGoogle Scholar
  23. Carioni, A., Gargantini, A., Riccobene, E., Scandurra, P. (2008). A scenario-based validation language for asms. In Börger, E, Butler, M., Bowen, J.P., Boca, P. (Eds.) Abstract State machines, B and Z (pp. 71–84). Berlin: Springer.Google Scholar
  24. Castañeda, L., Villegas, N. M., Müller, H. A. (2014). Self-adaptive applications: on the development of personalized web-tasking systems. In Proceedings of the 9th international symposium on software engineering for adaptive and self-managing systems. SEAMS 2014 (pp. 49–54). New York: ACM.Google Scholar
  25. Chai, M., & Schlingloff, B. H. (2014). Monitoring systems with extended live sequence charts. In Bonakdarpour, B., & Smolka, S.A. (Eds.) Runtime verification (pp. 48–63). Cham: Springer International Publishing.Google Scholar
  26. Cheng, B. H. C., de Lemos, R., Giese, H., Inverardi, P., Magee, J., Andersson, J., Becker, B., Bencomo, N., Brun, Y., Cukic, B., Di Marzo Serugendo, G., Dustdar, S., Finkelstein, A., Gacek, C., Geihs, K., Grassi, V., Karsai, G., Kienle, H. M., Kramer, J., Litoiu, M., Malek, S., Mirandola, R., Müller, H. A., Park, S., Shaw, M., Tichy, M., Tivoli, M., Weyns, D., Whittle, J. (2009). Software engineering for self-adaptive systems: a research roadmap. In Cheng, B.H.C., de Lemos, R., Giese, H., Inverardi, P., Magee, J. (Eds.) Software engineering for self-adaptive systems (pp. 1–26). Berlin: Springer.Google Scholar
  27. Cheng, B. H. C., Eder, K. I., Gogolla, M., Grunske, L., Litoiu, M., Müller, H.A., Pelliccione, P., Perini, A., Qureshi, N. A., Rumpe, B., Schneider, D., Trollmann, F., Villegas, N. M. (2014). Aßmann U Using models at runtime to address assurance for self-adaptive systems. In Bencomo, N., France, R., Cheng, B.H.C. (Eds.) Models@run.time: foundations, applications, and roadmaps (pp. 101–136). Cham: Springer International Publishing.CrossRefGoogle Scholar
  28. Clarke, E.M. Jr, Grumberg, O, Peled, D.A. (1999). Model checking. Cambridge: MIT Press.zbMATHGoogle Scholar
  29. Combes, P., Harel, D., Kugler, H. (2008). Modeling and verification of a telecommunication application using live sequence charts and the play-engine tool. Software & Systems Modeling, 7(2), 157–175.zbMATHCrossRefGoogle Scholar
  30. Damm, W., & Harel, D. (2001). Lscs: breathing life into message sequence charts. Formal Methods in System Design, 19(1), 45–80.zbMATHCrossRefGoogle Scholar
  31. D’Argenio, P. R, Hermanns, H., Katoen, J.P. (1999). On generative parallel composition11supported by the nwo/sion project 612-33-006 and the system validation centre/ctit. Electronic Notes in Theoretical Computer Science, 22, 30–54. pROBMIV’98, First International Workshop on Probabilistic Methods in Verification.CrossRefGoogle Scholar
  32. Di Nitto, E., Ghezzi, C., Metzger, A., Papazoglou, M., Pohl, K. (2008). A journey to highly dynamic, self-adaptive service-based applications. Automated Software Engg, 15(3-4), 313–341.CrossRefGoogle Scholar
  33. Ding, Z., Jiang, M., Zhou, M. (2016). Generating petri net-based behavioral models from textual use cases and application in railway networks. IEEE Transactions on Intelligent Transportation Systems, 17(12), 3330–3343.CrossRefGoogle Scholar
  34. Ding, Z., Shuai, T., Jiang, M. (2017). Reconvertor: transforming textual use cases to high-level message sequence chart. In: 2017 IEEE international conference on software quality, reliability and security companion (QRS-C), pp. 610–611.Google Scholar
  35. Edwards, R., & Bencomo, N. (2018). Desire: further understanding nuances of degrees of satisfaction of non-functional requirements trade-off. In Proceedings of the 13th International Conference on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’18 (pp. 12–18). New York: ACM.Google Scholar
  36. Eitan, N., & Harel, D. (2011). Adaptive behavioral programming. In Proceedings of the 2011 IEEE 23rd international conference on tools with artificial intelligence, ICTAI ’11 (pp. 685–692). Washington: IEEE Computer Society.Google Scholar
  37. Fahland, D. (2008). Oclets - a formal approach to adaptive systems using scenario-based concepts. Informatik-Berichte 223. Berlin: Humboldt-Universität zu.Google Scholar
  38. Fahland, D. (2009). Oclets – scenario-based modeling with petri nets. In Franceschinis, G., & Wolf, K. (Eds.) Applications and theory of petri nets: 30th international conference, PETRI NETS 2009, paris, france, june 22-26, 2009. Proceedings (pp. 223–242). Berlin: Springer.Google Scholar
  39. Filieri, A., Ghezzi, C., Tamburrelli, G. (2011). Run-time efficient probabilistic model checking. In Proceedings of the 33rd International Conference on Software Engineering, ICSE ’11 (pp. 341–350). New York: ACM.Google Scholar
  40. Fisher, J., Harel, D., Hubbard, E. J. A., Piterman, N., Stern, M. J., Swerdlin, N. (2005). Combining state-based and scenario-based approaches in modeling biological systems. In Danos, V., & Schachter, V. (Eds.) Computational methods in systems biology: International conference CMSB 2004, paris, france, may 26-28, 2004, Revised Selected Papers (pp. 236–241). Berlin: Springer.Google Scholar
  41. Gamma, E., Helm, R., Johnson, R., Vlissides, J. (1995). Design patterns: elements of reusable object-oriented software. Boston: Addison-Wesley Longman Publishing Co., Inc.zbMATHGoogle Scholar
  42. Georgas, J. C., & Taylor, R. N. (2008). Policy-based self-adaptive architectures: a feasibility study in the robotics domain. In Proceedings of the 2008 international workshop on software engineering for adaptive and self-managing systems, SEAMS ’08 (pp. 105–112). New York: ACM.Google Scholar
  43. Ghezzi, C., Greenyer, J., Manna, V.PL. (2012). Synthesizing dynamically updating controllers from changes in scenario-based specifications. In: 2012 7th international symposium on software engineering for adaptive and self-managing systems (SEAMS), pp. 145–154.Google Scholar
  44. Go, K., & Carroll, J. M. (2004). The blind men and the elephant: views of scenario-based system design. Interactions, 11(6), 44–53.CrossRefGoogle Scholar
  45. Goldsby, H. J., & Cheng, B. H. (2008a). Automatically generating behavioral models of adaptive systems to address uncertainty. In Proceedings of the 11th international conference on model driven engineering languages and systems, MoDELS ’08 (pp. 568–583). Berlin: Springer-Verlag.Google Scholar
  46. Goldsby, H. J., & Cheng, B. H. (2008b). Avida-mde: A digital evolution approach to generating models of adaptive software behavior. In Proceedings of the 10th Annual Conference on Genetic and Evolutionary Computation, GECCO ’08 (pp. 1751–1758). New York: ACM.Google Scholar
  47. Goldsby, H. J., Cheng, B. H. C., Zhang, J. (2008a). Amoeba-rt: run-time verification of adaptive software. In Giese, H. (Ed.) Models in software engineering (pp. 212–224). Berlin: Springer.Google Scholar
  48. Goldsby, H. J., Sawyer, P., Bencomo, N., Cheng, B. H. C., Hughes, D. (2008b). Goal-based modeling of dynamically adaptive system requirements. In 15Th annual IEEE international conference and workshop on the engineering of computer based systems (ecbs 2008) (pp. 36–45).Google Scholar
  49. Gordon, M., & Harel, D. (2009). Generating executable scenarios from natural language. In Proceedings of the 10th international conference on computational linguistics and intelligent text processing, CICLing ’09 (pp. 456–467). Berlin: Springer-Verlag.Google Scholar
  50. Greenyer, J., Gritzner, D., Gutjahr, T., Duente, T., Dulle, S., Deppe, F. D., Glade, N., Hilbich, M., Koenig, F., Luennemann, J., Prenner, N., Raetz, K., Schnelle, T., Singer, M., Tempelmeier, N., Voges, R. (2015). Scenarios@run.time – distributed execution of specifications on iot-connected robots. In Götz, S., Bencomo, N., Blair, G., Song, H. (Eds.) Proceedings of the 10th International Workshop on Models@Run.Time (MRT 2015), co-located with MODELS 2015, CEUR, CEUR Workshop Proceedings, (Vol. 1474 pp. 71–80).Google Scholar
  51. Gulia, S., & Choudhury, T. (2016). An efficient automated design to generate uml diagram from natural language specifications. In: 2016 6th international conference - cloud system and big data engineering (Confluence), pp. 641–648.Google Scholar
  52. Harel, D., & Maoz, S. (2008). Assert and negate revisited: modal semantics for umlsequence diagrams. Software & Systems Modeling, 7(2), 237–252.CrossRefGoogle Scholar
  53. Harel, D., & Thiagarajan, P. S. (2003). Message sequence charts. In Lavagno, L., Martin, G., Selic, B. (Eds.) UML for real: design of embedded real-time systems (pp. 77–105). US: Springer.Google Scholar
  54. Hermans, F., Pinzger, M., van Deursen, A. (2009). Domain-specific languages in practice: a user study on the success factors. In Schürr, A., Selic, B., Languages (Eds.) Model driven engineering and systems (pp. 423–437). Berlin: Springer.CrossRefGoogle Scholar
  55. Hinton, A., Kwiatkowska, M., Norman, G., Parker, D. (2006). Prism: a tool for automatic verification of probabilistic systems. In Hermanns, H., & Palsberg, J. (Eds.) Tools and algorithms for the construction and analysis of systems (pp. 441–444). Berlin: Springer.Google Scholar
  56. Horányi, G., Micskei, Z., Majzik, I. (2013). Scenario-based automated evaluation of test traces of autonomous systems. In Roy, M (Ed.) SAFECOMP 2013 - Workshop DECS (ERCIM/EWICS Workshop on Dependable Embedded and Cyber-physical Systems) of the 32nd international conference on computer safety, reliability and security (p. NA). France: Toulouse. https://hal.archives-ouvertes.fr/hal-00848607.
  57. Hussein, M., Yu, J., Han, J., Colman, A. (2012). Scenario-driven development of context-aware adaptive web services. In Proceedings of the 13th international conference on web information systems engineering, WISE’12 (pp. 228–242). Berlin: Springer-Verlag.CrossRefGoogle Scholar
  58. Hussein, M., Han, J., Yu, J., Colman, A. (2013). Scenario-based validation of requirements for context-aware adaptive services. In: 2013 IEEE 20th international conference on web services, pp 348–355.Google Scholar
  59. Jiao, W., & Sun, Y. (2013). Supporting adaptation of decentralized software based on application scenarios. Journal of Systems and Software, 86(7), 1891–1906.CrossRefGoogle Scholar
  60. Kam, N., Harel, D., Kugler, H., Marelly, R., Pnueli, A., Hubbard, J. A., Stern, M. J. (2004). Formal modelling of c. elegans development. a scenario-based approach. In Ciobanu, G., & Rozenberg, G. (Eds.) Modelling in molecular biology (pp. 151–173). Berlin: Springer.Google Scholar
  61. Katoen, J., Khattri, M., Zapreevt, I.S. (2005). A markov reward model checker. In: 2nd international conference on the quantitative evaluation of systems (QEST’05), pp. 243–244 .  https://doi.org/10.1109/QEST.2005.2.
  62. Kephart, J. O., & Chess, D. M. (2003). The vision of autonomic computing. Computer, 36(1), 41–50.MathSciNetCrossRefGoogle Scholar
  63. Khalastchi, E., & Kalech, M. (2018). On fault detection and diagnosis in robotic systems. ACM Comput Surv, 51(1), 9:1–9:24.CrossRefGoogle Scholar
  64. Kim, D., & Park, S. (2009). Reinforcement learning-based dynamic adaptation planning method for architecture-based self-managed software. In Proceedings of the 2009 ICSE workshop on software engineering for adaptive and self-managing systems, SEAMS ’09 (pp. 76–85). Washington: IEEE Computer Society.Google Scholar
  65. Kitchenham, B., & Brereton, P. (2013). A systematic review of systematic review process research in software engineering. Information and Software Technology, 55(12), 2049–2075.CrossRefGoogle Scholar
  66. Kitchenham, B., & Charters, S. (2007). Guidelines for performing systematic literature reviews in software engineering. Tech. rep.: Keele University and Durham University Joint Report.Google Scholar
  67. Kitchenham, B., Brereton, P., Budgen, D. (2012). Mapping study completeness and reliability - a case study. In 16th international conference on evaluation assessment in software engineering (EASE, (Vol. 2012 pp. 126–135).Google Scholar
  68. Kitchenham, B. A., Budgen, D., Pearl Brereton, O. (2011). Using mapping studies as the basis for further research - a participant-observer case study. Information and Software Technology, 53(6), 638–651.CrossRefGoogle Scholar
  69. Kitchenham, B. A., Budgen, D., Brereton P. (2015). Evidence-based software engineering and systematic reviews. Boca Raton: Chapman & Hall/CRC.Google Scholar
  70. Knauss, A., Schroeder, J., Berger, C., Eriksson, H. (2017). Software-related challenges of testing automated vehicles. In Proceedings of the 39th International Conference on Software Engineering Companion, ICSE-C ’17 (pp. 328–330). Piscataway: IEEE Press.Google Scholar
  71. Kof, L. (2008). From textual scenarios to message sequence charts: Inclusion of condition generation and actor extraction. In: 2008 16th IEEE International Requirements Engineering Conference, pp. 331–332.Google Scholar
  72. Krupitzer, C., Roth, F. M., VanSyckel, S., Schiele, G., Becker, C. (2015). A survey on engineering approaches for self-adaptive systems. Pervasive Mob Comput, 17(PB), 184–206.CrossRefGoogle Scholar
  73. Kugler, H. (2013). Biocharts: Unifying biological hypotheses with models and experiments. In: 2013 IEEE 9th international conference on e-science, pp. 317–325.Google Scholar
  74. Kwiatkowska, M. (2007). Quantitative verification: models, techniques and tools. In The 6th joint meeting on European software engineering conference and the ACM SIGSOFT symposium on the foundations of software engineering: Companion papers, ESEC-FSE companion ’07 (pp. 449–458). New York: ACM.  https://doi.org/10.1145/1295014.1295018.
  75. van Lamsweerde, A., & Willemet, L. (1998). Inferring declarative requirements specifications from operational scenarios. IEEE Transactions on Software Engineering, 24(12), 1089–1114.CrossRefGoogle Scholar
  76. de Lemos, R., Giese, H., Müller, H. A., Shaw, M., Andersson, J., Litoiu, M., Schmerl, B., Tamura, G., Villegas, N. M., Vogel, T., Weyns, D., Baresi, L, Becker, B., Bencomo, N., Brun, Y., Cukic, B., Desmarais, R., Dustdar, S., Engels, G., Geihs, K., Göschka, K. M., Gorla, A., Grassi, V., Inverardi, P., Karsai, G., Kramer, J., Lopes, A., Magee, J., Malek, S., Mankovskii, S., Mirandola, R., Mylopoulos, J., Nierstrasz, O., Pezzè, M., Prehofer, C., Schäfer, W., Schlichting, R., Smith, D. B., Sousa, J. P., Tahvildari, L., Wong, K., Wuttke, J. (2013). Software engineering for self-adaptive systems: a second research roadmap. In de Lemos, R., Giese, H., Müller, H.A., Shaw, M. (Eds.) Software engineering for self-adaptive systems II: international seminar, dagstuhl castle, germany, october 24-29, 2010, Revised Selected and Invited Papers (pp. 1–32). Berlin: Springer.Google Scholar
  77. Letier, E., Kramer, J., Magee, J., Uchitel, S. (2005). Monitoring and control in scenario-based requirements analysis. In: Proceedings. 27th international conference on software engineering, 2005. ICSE 2005., pp. 382–391.Google Scholar
  78. Lu, T., & Bao, J. (2012). A systematic approach to context aware service design. Journal of Computers, 7, 207–217.Google Scholar
  79. Luckey, M., Nagel, B., Gerth, C., Engels, G. (2011). Adapt cases: extending use cases for adaptive systems. In Proceedings of the 6th international symposium on software engineering for adaptive and self-managing systems, SEAMS ’11 (pp. 30–39). New York: ACM.Google Scholar
  80. Magee, J., & Kramer, J. (2006). Concurrency: state models and java programs, 2nd edn. New York: Wiley Publishing.zbMATHGoogle Scholar
  81. Maoz, S. (2009). Using model-based traces as runtime models. Computer, 42(10), 28–36.CrossRefGoogle Scholar
  82. Mason, P. A. J., & Supsrisupachai, S. (2009). Paraphrasing use case descriptions and sequence diagrams: an approach with tool support. In 2009 6th international conference on electrical engineering/electronics, computer, telecommunications and information technology, (Vol. 02 pp. 722–725).Google Scholar
  83. Matevska, J., & Hasselbring, W. (2007). A scenario-based approach to increasing service availability at runtime reconfiguration of component-based systems. In 33rd EUROMICRO conference on software engineering and advanced applications (EUROMICRO 2007) (pp. 137–148).Google Scholar
  84. Morin, B., Barais, O., Jezequel, J. M., Fleurey, F., Solberg, A. (2009). Models@ run.time to support dynamic adaptation. Computer, 42(10), 44–51.CrossRefGoogle Scholar
  85. Moshirpour, M., Mousavi, A., Far, B. H. (2010). Model based detection of implied scenarios in multi agent systems. In: 2010 IEEE international conference on information reuse integration, pp. 63–68.Google Scholar
  86. Muniz, L. L., Netto, U. S. C., Maia, P. HM. (2015). Tcg - a model-based testing tool for functional and statistical testing. In: ICEIS.Google Scholar
  87. Olaechea, R., Atlee, J., Legay, A., Fahrenberg, U. (2018). Trace checking for dynamic software product lines. In Proceedings of the 13th international conference on software engineering for adaptive and self-managing systems, SEAMS ’18 (pp. 69–75). New York: ACM.Google Scholar
  88. OMG. (2017). Omg unified modeling language. https://www.omg.org/spec/UML.
  89. Oreizy, P., Gorlick, M. M., Taylor, R. N., Heimbigner, D., Johnson, G., Medvidovic, N., Quilici, A., Rosenblum, D. S., Wolf, A. L. (1999). An architecture-based approach to self-adaptive software. IEEE Intelligent Systems, 14(3), 54–62.CrossRefGoogle Scholar
  90. Panzica La Manna, V., Greenyer, J., Ghezzi, C., Brenner, C. (2013). Formalizing correctness criteria of dynamic updates derived from specification changes. In Proceedings of the 8th international symposium on software engineering for adaptive and self-managing systems, SEAMS ’13 (pp. 63–72). Piscataway: IEEE Press.Google Scholar
  91. Perez, B., & Correal, D. (2011). A model driven approach to the analysis of quality scenarios within self-adaptable soa systems. Electronic Notes in Theoretical Computer Science, 281(Supplement C), 113–126. Proceedings of the 2011 Latin American Conference in Informatics (CLEI).CrossRefGoogle Scholar
  92. Petersen, K., Vakkalanka, S., Kuzniarz, L. (2015). Guidelines for conducting systematic mapping studies in software engineering: an update. Information and Software Technology, 64(Supplement C), 1–18.CrossRefGoogle Scholar
  93. Petri, C .A. (1962). Kommunikation mit automaten. Universität Hamburg: PhD thesis.Google Scholar
  94. Pike, L., Niller, S., Wegmann, N. (2012). Runtime verification for ultra-critical systems. In Khurshid, S., & Sen, K. (Eds.) Runtime verification (pp. 310–324). Berlin: Springer.Google Scholar
  95. Rodrigues, G., Rosenblum, D., Uchitel, S. (2005). Using scenarios to predict the reliability of concurrent component-based software systems. In Proceedings of the 8th international conference, held as part of the joint European conference on theory and practice of software conference on fundamental approaches to software engineering, FASE’05 (pp. 111–126). Berlin: Springer-Verlag.CrossRefGoogle Scholar
  96. Rolland, C., Ben Achour, C., Cauvet, C., Ralyté, J., Sutcliffe, A., Maiden, N., Jarke, M., Haumer, P., Pohl, K., Dubois, E., Heymans, P. (1998). A proposal for a scenario classification framework. Requirements Engineering, 3(1), 23–47.CrossRefGoogle Scholar
  97. Sadot, A., Fisher, J., Barak, D., Admanit, Y., Stern, M. J., Hubbard, E. J. A., Harel, D. (2008). Toward verified biological models. IEEE/ACM Trans Comput Biol Bioinformatics, 5(2), 223–234.CrossRefGoogle Scholar
  98. Salehie, M., & Tahvildari, L. (2009). Self-adaptive software: landscape and research challenges. ACM Trans Auton Adapt Syst, 4(2), 14:1–14:42.CrossRefGoogle Scholar
  99. Sarmiento, E., Almentero, E, Leite, C.S.P.J., Sotomayor, G. (2015). Mapping textual scenarios to analyzable petri-net models. In Proceedings of the 17th International Conference on Enterprise Information Systems - 2 SCITEPRESS - Science and Technology Publications, Lda, Portugal, ICEIS 2015, pp. 494–501.Google Scholar
  100. Sitou, W., & Spanfelner, B. (2007). Towards requirements engineering for context adaptive systems. In Proceedings of the 31st annual international computer software and applications conference - vol. 02, COMPSAC ’07 (pp. 593–600). Washington: IEEE Computer Society.Google Scholar
  101. Szvetits, M., & Zdun, U. (2016). Systematic literature review of the objectives, techniques, kinds, and architectures of models at runtime. Software & Systems Modeling, 15(1), 31–69.CrossRefGoogle Scholar
  102. Tamura, G., Villegas, N.M., Müller, H.A., Sousa, J.P., Becker, B., Karsai, G., Mankovskii, S, Pezzè, M., Schäfer, W., Tahvildari, L., Wong, K. (2013). Towards practical runtime verification and validation of self-adaptive software systems. In de Lemos, R., Giese, H., Müller, H.A., Shaw, M. (Eds.) Software engineering for self-adaptive systems II: international seminar, dagstuhl castle, germany, october 24-29, 2010, Revised Selected and Invited Papers (pp. 108–132). Berlin: Springer.CrossRefGoogle Scholar
  103. Uchitel, S., Kramer, J., Magee, J. (2003). Synthesis of behavioral models from scenarios. IEEE Transactions on Software Engineering, 29(2), 99–115.CrossRefGoogle Scholar
  104. Uchitel, S, Alrajeh, D., Ben-David, S., Braberman, V., Chechik, M., De Caso, G., D’Ippolito, N., Fischbein, D., Garbervetsky, D., Kramer, J., Russo, A., Sibay, G. (2013). Supporting incremental behaviour model elaboration. Computer Science - Research and Development, 28(4), 279–293.CrossRefGoogle Scholar
  105. Vogel, T., Neumann, S., Hildebrandt, S., Giese, H., Becker, B. (2009). Model-driven architectural monitoring and adaptation for autonomic systems. In Proceedings of the 6th International Conference on Autonomic Computing, ICAC ’09 (pp. 67–68). New York: ACM.Google Scholar
  106. Vrbaski, M., Mussbacher, G., Petriu, D., Amyot, D. (2012). Goal models as run-time entities in context-aware systems. In Proceedings of the 7th workshop on Models@Run.Time, MRT ’12 (pp. 3–8). New York: ACM.Google Scholar
  107. Waignier, G., Le Meur, A. F., Duchien, L. (2009). A model-based framework to design and debug safe component-based autonomic systems. In Mirandola, R., Gortona, I., Hofmeiste, C. (Eds.) International conference on the quality of software-architectures. Lecture Notes in Computer Science, (Vol. 5581 pp. 1–17). Pennsylvania: Springer-Verlag.Google Scholar
  108. Wang, Y., McIlraith, S. A., Yu, Y., Mylopoulos, J. (2008). Monitoring and diagnosing software requirements. Automated Software Engineering, 16(1), 3.CrossRefGoogle Scholar
  109. Weyns, D., & Calinescu, R. (2015). Tele assistance: a self-adaptive service-based system examplar. In Proceedings of the 10th international symposium on software engineering for adaptive and self-managing systems, SEAMS ’15 (pp. 88–92). Piscataway: IEEE Press.Google Scholar
  110. Weyns, D., Bencomo, N., Calinescu, R., Camara, J., Ghezzi, C., Grassi, V., Grunske, L., Inverardi, P., Jezequel, J. M., Malek, S., Mirandola, R., Mori, M., Tamburrelli, G. (2017). Perpetual assurances for self-adaptive systems. In De lemos, R., Garlan, D., Ghezzi, C., Giese, H. (Eds.) Software engineering for self-adaptive systems III. Assurances (pp. 31–63). Cham: Springer International Publishing.Google Scholar
  111. Whittle, J., & Schumann, J. (2006). Scenario-based engineering of multi-agent systems. In Rouff, C.A., Hinchey, M., Rash, J., Truszkowski, W., Gordon-Spears, D. (Eds.) Agent technology from a formal perspective (pp. 159–189). London: Springer.Google Scholar
  112. Zeng, L., Benatallah, B., Ngu, A. H. H., Dumas, M., Kalagnanam, J., Chang, H. (2004). Qos-aware middleware for web services composition. IEEE Transactions on Software Engineering, 30(5), 311–327.CrossRefGoogle Scholar
  113. Zhang, P., Li, W., Wan, D., Grunske, L. (2011). Monitoring of probabilistic timed property sequence charts. Softw Pract Exper, 41(7), 841–866.CrossRefGoogle Scholar
  114. Zhang, P., Cheng, K., Gao, J. (2018). Android-srv: scenario-based runtime verification of android applications. International Journal of Software Engineering and Knowledge Engineering, 28(02), 239–257. https://www.worldscientific.com/doi/pdf/10.1142/S0218194018500080.CrossRefGoogle Scholar
  115. Zhu, Y, Huang, G, Mei, H. (2004). Quality attribute scenario based architectural modeling for self-adaptation supported by architecture-based reflective middleware. In: 11th Asia-pacific software engineering conference, pp. 2–9.Google Scholar

Copyright information

© Springer Science+Business Media, LLC, part of Springer Nature 2020

Authors and Affiliations

  1. 1.State University of Ceará (UECE)FortalezaBrazil
  2. 2.Lero - the Irish Software Research CentreUniversity of LimerickLimerickIreland

Personalised recommendations